diff --git a/.claude/skills/mendix/docker-workflow.md b/.claude/skills/mendix/docker-workflow.md index 75b64e0..e7e4ad2 100644 --- a/.claude/skills/mendix/docker-workflow.md +++ b/.claude/skills/mendix/docker-workflow.md @@ -50,6 +50,21 @@ mxcli docker run -p app.mpr --fresh --wait `docker run` handles everything: downloads MxBuild and runtime (if not cached), initializes the Docker stack (if needed), builds the PAD package, starts the containers, and optionally waits for the runtime to report successful startup. +## Creating an Empty Mendix App + +To create a new blank Mendix project for testing (requires mxbuild to be downloaded first): + +```bash +# Download mxbuild if not already cached +mxcli setup mxbuild --version 11.6.4 + +# Create a blank project +mkdir -p /path/to/my-app +~/.mxcli/mxbuild/{version}/modeler/mx create-project --app-name MyApp --output-dir /path/to/my-app +``` + +The `mx create-project` command creates an MPR v2 project with the standard Mendix module structure. You can then use the Docker workflow to build and run it. + ## Step-by-Step Workflow If you prefer more control, use the individual commands: @@ -65,6 +80,10 @@ mxcli setup mxbuild -p app.mpr # Download Mendix runtime matching the project version mxcli setup mxruntime -p app.mpr +# Or specify version explicitly (without a project) +mxcli setup mxbuild --version 11.6.4 +mxcli setup mxruntime --version 11.6.4 + # Or preview what would be downloaded mxcli setup mxbuild -p app.mpr --dry-run mxcli setup mxruntime -p app.mpr --dry-run @@ -72,6 +91,27 @@ mxcli setup mxruntime -p app.mpr --dry-run MxBuild is cached at `~/.mxcli/mxbuild/{version}/` and the runtime at `~/.mxcli/runtime/{version}/`. Both are reused across builds. +#### Runtime-to-MxBuild Copying (PAD Build Prerequisite) + +MxBuild 11.6.3+ expects runtime files (`pad/`, `lib/`, `launcher/`, `agents/`) inside its own `runtime/` directory, but `mxcli setup mxbuild` only downloads the build tools (not the full runtime). If the PAD build fails with `StudioPro.conf.hbs does not exist` or `ClassNotFoundException`, copy the runtime directories into mxbuild: + +```bash +VERSION=11.6.4 # replace with your version + +# After downloading both mxbuild and mxruntime: +cp -r ~/.mxcli/runtime/$VERSION/runtime/pad ~/.mxcli/mxbuild/$VERSION/runtime/pad +cp -r ~/.mxcli/runtime/$VERSION/runtime/lib ~/.mxcli/mxbuild/$VERSION/runtime/lib +cp -r ~/.mxcli/runtime/$VERSION/runtime/launcher ~/.mxcli/mxbuild/$VERSION/runtime/launcher +cp -r ~/.mxcli/runtime/$VERSION/runtime/agents ~/.mxcli/mxbuild/$VERSION/runtime/agents +``` + +**Important:** The PAD build output may only include partial runtime bundles (5 jars instead of 354). If the runtime fails to start with `ClassNotFoundException: com.mendix.container.support.EventProcessor`, copy the full runtime into the PAD build output: + +```bash +rm -rf /path/to/project/.docker/build/lib/runtime +cp -r ~/.mxcli/runtime/$VERSION/runtime /path/to/project/.docker/build/lib/runtime +``` + ### 2. Initialize Docker stack (first time only) ```bash @@ -81,6 +121,16 @@ mxcli docker init -p app.mpr This creates a `.docker/` directory with Docker Compose configuration for the Mendix app + PostgreSQL. +**Port conflicts:** If default ports (8080/8090/5432) are already in use, check with `ss -tlnp | grep -E '808|809|543'` and use `--port-offset N` to shift all ports: + +```bash +# Check which ports are occupied +ss -tlnp | grep -E '808[0-9]|809[0-9]|543[0-9]' + +# Use offset to avoid conflicts (e.g., offset 5 → 8085/8095/5437) +mxcli docker init -p app.mpr --port-offset 5 +``` + ### 3. Check project for errors ```bash @@ -346,6 +396,9 @@ All defaults can be overridden in `.docker/.env`. | Build fails with version error | Requires Mendix >= 11.6.1 for PAD support | | No Dockerfile in PAD output | Normal for MxBuild 11.6.3+ — `mxcli docker build` auto-generates one | | Runtime not found / runtimelauncher.jar missing | Run `mxcli setup mxruntime -p app.mpr` or let `docker build` auto-download | +| `StudioPro.conf.hbs does not exist` | Runtime not linked into mxbuild — see "Runtime-to-MxBuild Copying" above | +| `ClassNotFoundException: EventProcessor` | PAD has partial runtime bundles — copy full runtime into `.docker/build/lib/runtime/` (see above) | +| Port already allocated | Check ports with `ss -tlnp \| grep 808` and use `docker init --port-offset N --force` | | `' etc/Default' is not a file` | Dockerfile CMD passes config arg — `docker build` patches this automatically | | `DatabasePassword has no value` | Ensure `RUNTIME_PARAMS_DATABASE*` env vars are in docker-compose.yml — re-run `mxcli docker init --force` | | `Password should not be empty (debugger)` | Add `RUNTIME_DEBUGGER_PASSWORD` — re-run `mxcli docker init --force` | diff --git a/.claude/skills/mendix/generate-domain-model.md b/.claude/skills/mendix/generate-domain-model.md index 7c1b799..3d5321b 100644 --- a/.claude/skills/mendix/generate-domain-model.md +++ b/.claude/skills/mendix/generate-domain-model.md @@ -326,6 +326,29 @@ COMMENT 'Additional documentation'; **Naming Convention**: `{FromEntity}_{ToEntity}` (e.g., `Order_Customer`, `Transaction_Account`) +#### Calculated Attributes + +Calculated attributes derive their value from a microflow at runtime. Use `CALCULATED BY Module.Microflow` to specify the calculation microflow. + +**IMPORTANT: CALCULATED attributes are only supported on PERSISTENT entities.** Using CALCULATED on non-persistent entities will produce a validation error. + +```sql +@Position(100, 100) +CREATE PERSISTENT ENTITY Module.OrderLine ( + /** Unit price */ + UnitPrice: Decimal NOT NULL, + /** Quantity ordered */ + Quantity: Integer NOT NULL, + /** Total price, calculated by microflow */ + TotalPrice: Decimal CALCULATED BY Module.CalcTotalPrice +); +``` + +**Syntax variants:** +- `CALCULATED BY Module.Microflow` — recommended, binds the calculation microflow directly +- `CALCULATED Module.Microflow` — also valid (`BY` keyword is optional) +- `CALCULATED` — bare form, marks as calculated but requires manual microflow binding in Studio Pro + ### Data Types | Type | Example | Description | diff --git a/.claude/skills/mendix/manage-security.md b/.claude/skills/mendix/manage-security.md index 626fb70..20fc766 100644 --- a/.claude/skills/mendix/manage-security.md +++ b/.claude/skills/mendix/manage-security.md @@ -171,13 +171,18 @@ ALTER PROJECT SECURITY DEMO USERS OFF; ### Demo Users ```sql --- Create demo user with roles +-- Create demo user (auto-detects entity that generalizes System.User) CREATE DEMO USER 'demo_admin' PASSWORD 'Admin123!' (Administrator, SuperAdmin); +-- Create demo user with explicit entity +CREATE DEMO USER 'demo_admin' PASSWORD 'Admin123!' ENTITY Administration.Account (Administrator, SuperAdmin); + -- Remove demo user DROP DEMO USER 'demo_admin'; ``` +The ENTITY clause specifies which entity (generalizing `System.User`) to use. If omitted, it auto-detects the unique System.User subtype in the project. If multiple subtypes exist, you must specify ENTITY explicitly. + ## Starlark Lint Rule APIs Security data is available in Starlark lint rules (`.star` files): diff --git a/.gitignore b/.gitignore index 041ca80..ce0d1ce 100644 --- a/.gitignore +++ b/.gitignore @@ -54,3 +54,6 @@ grammardoc *.pptx # Excluded skills .claude/skills/mendix/migrate-outsystems.md + +# Snap tool binary (used for BSON fixture generation) +snap-bson diff --git a/CLAUDE.md b/CLAUDE.md index f63b74c..40db366 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -325,9 +325,11 @@ Full syntax tables for all MDL statements (microflows, pages, security, navigati - Data import from external databases into Mendix app DB (`IMPORT FROM ... INTO ... MAP ...`) - Database Connector generation from external schema (`SQL GENERATE CONNECTOR INTO `) - EXECUTE DATABASE QUERY microflow action (static, dynamic SQL, parameterized, runtime connection override) +- CREATE/DROP WORKFLOW with user tasks, decisions, parallel splits, and other activity types +- CALCULATED BY microflow syntax for calculated attributes **Not Yet Implemented:** -- 48 of 52 metamodel domains (workflows, REST, etc.) +- 47 of 52 metamodel domains (REST, etc.) - Delta/change tracking system - Runtime type reflection diff --git a/Makefile b/Makefile index 948d1e1..fdec9cf 100644 --- a/Makefile +++ b/Makefile @@ -23,7 +23,7 @@ VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev BUILD_TIME = $(shell date -u +"%Y-%m-%dT%H:%M:%SZ") LDFLAGS = -ldflags "-X main.Version=$(VERSION) -X main.BuildTime=$(BUILD_TIME)" -.PHONY: build release clean test test-mdl grammar completions sync-skills sync-commands sync-lint-rules sync-changelog sync-all docs documentation vscode-ext vscode-install source-tree sbom sbom-report lint lint-go lint-ts fmt vet +.PHONY: build build-debug release clean test test-mdl grammar completions sync-skills sync-commands sync-lint-rules sync-changelog sync-all docs documentation vscode-ext vscode-install source-tree sbom sbom-report lint lint-go lint-ts fmt vet # Helper: copy file only if content differs (avoids mtime updates that invalidate go build cache) # Usage: $(call copy-if-changed,src,dst) @@ -101,6 +101,12 @@ build: sync-all completions CGO_ENABLED=0 go build -o $(BUILD_DIR)/source_tree ./cmd/source_tree @echo "Built $(BUILD_DIR)/$(BINARY_NAME) $(BUILD_DIR)/source_tree" +# Build with debug tools (includes bson discover/compare/dump) +build-debug: sync-all completions + @mkdir -p $(BUILD_DIR) + CGO_ENABLED=0 go build -tags debug $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-debug $(CMD_PATH) + @echo "Built $(BUILD_DIR)/$(BINARY_NAME)-debug (debug build with bson tools)" + # Build for all platforms (CGO_ENABLED=0 for cross-compilation) release: clean sync-all @mkdir -p $(BUILD_DIR) diff --git a/bson/classify.go b/bson/classify.go new file mode 100644 index 0000000..c678289 --- /dev/null +++ b/bson/classify.go @@ -0,0 +1,48 @@ +package bson + +// FieldCategory classifies BSON fields by their role in serialization. +type FieldCategory int + +const ( + // Semantic fields carry business meaning (e.g., Name, Caption, Expression). + Semantic FieldCategory = iota + // Structural fields are BSON framing (e.g., $ID, $Type, PersistentId). + Structural + // Layout fields control visual positioning (e.g., RelativeMiddlePoint, Size). + Layout +) + +func (c FieldCategory) String() string { + switch c { + case Semantic: + return "Semantic" + case Structural: + return "Structural" + case Layout: + return "Layout" + default: + return "Unknown" + } +} + +var structuralFields = map[string]bool{ + "$ID": true, + "$Type": true, + "PersistentId": true, +} + +var layoutFields = map[string]bool{ + "RelativeMiddlePoint": true, + "Size": true, +} + +// classifyField returns the FieldCategory for a given BSON storage name. +func classifyField(storageName string) FieldCategory { + if structuralFields[storageName] { + return Structural + } + if layoutFields[storageName] { + return Layout + } + return Semantic +} diff --git a/bson/compare.go b/bson/compare.go new file mode 100644 index 0000000..7612dad --- /dev/null +++ b/bson/compare.go @@ -0,0 +1,421 @@ +package bson + +import ( + "fmt" + "strings" +) + +// DiffType represents the kind of difference between two BSON trees. +type DiffType int + +const ( + // OnlyInLeft indicates a field present only in the left document. + OnlyInLeft DiffType = iota + // OnlyInRight indicates a field present only in the right document. + OnlyInRight + // ValueMismatch indicates the same key has different values. + ValueMismatch + // TypeMismatch indicates the same key has different Go types. + TypeMismatch +) + +func (d DiffType) String() string { + switch d { + case OnlyInLeft: + return "only-in-left" + case OnlyInRight: + return "only-in-right" + case ValueMismatch: + return "value-mismatch" + case TypeMismatch: + return "type-mismatch" + default: + return "unknown" + } +} + +// Diff represents a single difference between two BSON trees. +type Diff struct { + Path string + Type DiffType + LeftValue string // formatted value (empty when OnlyInRight) + RightValue string // formatted value (empty when OnlyInLeft) +} + +// CompareOptions controls what to include in comparison. +type CompareOptions struct { + IncludeAll bool // if true, include structural/layout fields +} + +// defaultSkipFields are fields skipped by default (structural + layout). +var defaultSkipFields = map[string]bool{ + "$ID": true, + "PersistentId": true, + "RelativeMiddlePoint": true, + "Size": true, +} + +// Compare performs a recursive diff of two BSON document trees. +// Input maps come from bson.Unmarshal into bson.M (map[string]any). +func Compare(left, right map[string]any, opts CompareOptions) []Diff { + return compareMaps(left, right, "", opts) +} + +// compareMaps recursively compares two maps. +func compareMaps(left, right map[string]any, path string, opts CompareOptions) []Diff { + var diffs []Diff + + for key, leftVal := range left { + if !opts.IncludeAll && defaultSkipFields[key] { + continue + } + + fullPath := joinPath(path, key) + + rightVal, exists := right[key] + if !exists { + diffs = append(diffs, Diff{ + Path: fullPath, + Type: OnlyInLeft, + LeftValue: FormatValue(leftVal), + }) + continue + } + + diffs = append(diffs, compareValues(leftVal, rightVal, fullPath, opts)...) + } + + for key, rightVal := range right { + if !opts.IncludeAll && defaultSkipFields[key] { + continue + } + + if _, exists := left[key]; exists { + continue + } + + fullPath := joinPath(path, key) + diffs = append(diffs, Diff{ + Path: fullPath, + Type: OnlyInRight, + RightValue: FormatValue(rightVal), + }) + } + + return diffs +} + +// compareValues compares two values at the same path. +func compareValues(leftVal, rightVal any, path string, opts CompareOptions) []Diff { + if leftVal == nil && rightVal == nil { + return nil + } + if leftVal == nil { + return []Diff{{ + Path: path, + Type: ValueMismatch, + LeftValue: "null", + RightValue: FormatValue(rightVal), + }} + } + if rightVal == nil { + return []Diff{{ + Path: path, + Type: ValueMismatch, + LeftValue: FormatValue(leftVal), + RightValue: "null", + }} + } + + // Both are maps → recurse + leftMap, leftIsMap := toMap(leftVal) + rightMap, rightIsMap := toMap(rightVal) + if leftIsMap && rightIsMap { + return compareMaps(leftMap, rightMap, path, opts) + } + + // Both are slices → smart array matching + leftSlice, leftIsSlice := toSlice(leftVal) + rightSlice, rightIsSlice := toSlice(rightVal) + if leftIsSlice && rightIsSlice { + return compareSlices(leftSlice, rightSlice, path, opts) + } + + // Type mismatch (one is map, other is slice, etc.) + if leftIsMap != rightIsMap || leftIsSlice != rightIsSlice { + return []Diff{{ + Path: path, + Type: TypeMismatch, + LeftValue: FormatValue(leftVal), + RightValue: FormatValue(rightVal), + }} + } + + // Scalar comparison + leftStr := fmt.Sprintf("%v", leftVal) + rightStr := fmt.Sprintf("%v", rightVal) + if leftStr != rightStr { + return []Diff{{ + Path: path, + Type: ValueMismatch, + LeftValue: FormatValue(leftVal), + RightValue: FormatValue(rightVal), + }} + } + + return nil +} + +// compareSlices compares two slices with smart matching. +// For arrays of objects with $Type+Name fields, match by identity rather than index. +func compareSlices(left, right []any, path string, opts CompareOptions) []Diff { + // Check if elements can be identity-matched (maps with $Type or Name) + if canIdentityMatch(left) || canIdentityMatch(right) { + return compareSlicesByIdentity(left, right, path, opts) + } + + // Fall back to index-based comparison + var diffs []Diff + + minLen := len(left) + if len(right) < minLen { + minLen = len(right) + } + + for i := range minLen { + elemPath := fmt.Sprintf("%s[%d]", path, i) + diffs = append(diffs, compareValues(left[i], right[i], elemPath, opts)...) + } + + for i := minLen; i < len(left); i++ { + diffs = append(diffs, Diff{ + Path: fmt.Sprintf("%s[%d]", path, i), + Type: OnlyInLeft, + LeftValue: FormatValue(left[i]), + }) + } + + for i := minLen; i < len(right); i++ { + diffs = append(diffs, Diff{ + Path: fmt.Sprintf("%s[%d]", path, i), + Type: OnlyInRight, + RightValue: FormatValue(right[i]), + }) + } + + return diffs +} + +// identityKey builds a matching key from a map element using $Type and/or Name. +func identityKey(m map[string]any) string { + typeName, _ := m["$Type"].(string) + name, _ := m["Name"].(string) + if typeName != "" && name != "" { + return typeName + ":" + name + } + if typeName != "" { + return typeName + } + if name != "" { + return ":" + name + } + return "" +} + +// canIdentityMatch returns true if at least one element in the slice is a map +// with a "$Type" or "Name" key. +func canIdentityMatch(slice []any) bool { + for _, elem := range slice { + m, ok := toMap(elem) + if ok && identityKey(m) != "" { + return true + } + } + return false +} + +// compareSlicesByIdentity matches array elements by $Type+Name identity. +func compareSlicesByIdentity(left, right []any, path string, opts CompareOptions) []Diff { + var diffs []Diff + + type indexedMap struct { + index int + m map[string]any + } + + // Build identity → element mapping for both sides. + // Elements without identity keys fall back to index-based comparison. + leftByKey := map[string]indexedMap{} + var leftUnkeyed []indexedMap + for i, elem := range left { + m, ok := toMap(elem) + if !ok { + leftUnkeyed = append(leftUnkeyed, indexedMap{i, nil}) + continue + } + key := identityKey(m) + if key == "" { + leftUnkeyed = append(leftUnkeyed, indexedMap{i, m}) + continue + } + leftByKey[key] = indexedMap{i, m} + } + + rightByKey := map[string]indexedMap{} + var rightUnkeyed []indexedMap + for i, elem := range right { + m, ok := toMap(elem) + if !ok { + rightUnkeyed = append(rightUnkeyed, indexedMap{i, nil}) + continue + } + key := identityKey(m) + if key == "" { + rightUnkeyed = append(rightUnkeyed, indexedMap{i, m}) + continue + } + rightByKey[key] = indexedMap{i, m} + } + + // Match by identity key + matchedRight := map[string]bool{} + for key, lEntry := range leftByKey { + rEntry, exists := rightByKey[key] + if !exists { + elemPath := fmt.Sprintf("%s[%s]", path, key) + diffs = append(diffs, Diff{ + Path: elemPath, + Type: OnlyInLeft, + LeftValue: FormatValue(lEntry.m), + }) + continue + } + matchedRight[key] = true + elemPath := fmt.Sprintf("%s[%s]", path, key) + diffs = append(diffs, compareMaps(lEntry.m, rEntry.m, elemPath, opts)...) + } + + for key, rEntry := range rightByKey { + if matchedRight[key] { + continue + } + elemPath := fmt.Sprintf("%s[%s]", path, key) + diffs = append(diffs, Diff{ + Path: elemPath, + Type: OnlyInRight, + RightValue: FormatValue(rEntry.m), + }) + } + + // Handle unkeyed elements by index + unkeyedMin := len(leftUnkeyed) + if len(rightUnkeyed) < unkeyedMin { + unkeyedMin = len(rightUnkeyed) + } + for i := range unkeyedMin { + elemPath := fmt.Sprintf("%s[%d]", path, leftUnkeyed[i].index) + diffs = append(diffs, compareValues(left[leftUnkeyed[i].index], right[rightUnkeyed[i].index], elemPath, opts)...) + } + for i := unkeyedMin; i < len(leftUnkeyed); i++ { + elemPath := fmt.Sprintf("%s[%d]", path, leftUnkeyed[i].index) + diffs = append(diffs, Diff{ + Path: elemPath, + Type: OnlyInLeft, + LeftValue: FormatValue(left[leftUnkeyed[i].index]), + }) + } + for i := unkeyedMin; i < len(rightUnkeyed); i++ { + elemPath := fmt.Sprintf("%s[%d]", path, rightUnkeyed[i].index) + diffs = append(diffs, Diff{ + Path: elemPath, + Type: OnlyInRight, + RightValue: FormatValue(right[rightUnkeyed[i].index]), + }) + } + + return diffs +} + +// FormatDiffs returns a human-readable diff report. +func FormatDiffs(diffs []Diff) string { + if len(diffs) == 0 { + return "No differences found." + } + + var sb strings.Builder + + onlyLeft, onlyRight, valueMismatch, typeMismatch := 0, 0, 0, 0 + + for _, d := range diffs { + switch d.Type { + case OnlyInLeft: + onlyLeft++ + fmt.Fprintf(&sb, " - %s: %s (only in left)\n", d.Path, d.LeftValue) + case OnlyInRight: + onlyRight++ + fmt.Fprintf(&sb, " + %s: %s (only in right)\n", d.Path, d.RightValue) + case ValueMismatch: + valueMismatch++ + fmt.Fprintf(&sb, " ≠ %s: %s vs %s\n", d.Path, d.LeftValue, d.RightValue) + case TypeMismatch: + typeMismatch++ + fmt.Fprintf(&sb, " ≠ %s: %s vs %s (type mismatch)\n", d.Path, d.LeftValue, d.RightValue) + } + } + + total := onlyLeft + onlyRight + valueMismatch + typeMismatch + fmt.Fprintf(&sb, "\nSummary: %d differences, %d only-in-left, %d only-in-right, %d value-mismatches", + total, onlyLeft, onlyRight, valueMismatch+typeMismatch) + + return sb.String() +} + +// FormatValue formats a value for display, truncating long output. +func FormatValue(val any) string { + switch v := val.(type) { + case nil: + return "null" + case string: + if len(v) > 100 { + return fmt.Sprintf("%q... (truncated)", v[:100]) + } + return fmt.Sprintf("%q", v) + case map[string]any: + typeName, _ := v["$Type"].(string) + if typeName != "" { + return fmt.Sprintf("{%s ...}", typeName) + } + return fmt.Sprintf("{map with %d keys}", len(v)) + case []any: + return fmt.Sprintf("[array with %d elements]", len(v)) + case bool: + return fmt.Sprintf("%v", v) + default: + s := fmt.Sprintf("%v", val) + if len(s) > 100 { + return s[:100] + "... (truncated)" + } + return s + } +} + +// toMap attempts to convert a value to map[string]any. +func toMap(val any) (map[string]any, bool) { + m, ok := val.(map[string]any) + return m, ok +} + +// toSlice attempts to convert a value to []any. +func toSlice(val any) ([]any, bool) { + // bson.M unmarshals arrays as primitive.A which is []interface{} + s, ok := val.([]any) + return s, ok +} + +// joinPath builds a dotted path. +func joinPath(base, key string) string { + if base == "" { + return key + } + return base + "." + key +} diff --git a/bson/compare_test.go b/bson/compare_test.go new file mode 100644 index 0000000..1239c93 --- /dev/null +++ b/bson/compare_test.go @@ -0,0 +1,222 @@ +package bson + +import ( + "strings" + "testing" +) + +func TestCompareIdentical(t *testing.T) { + doc := map[string]any{ + "$Type": "Workflows$Workflow", + "Name": "MyWorkflow", + "Title": "Hello", + } + diffs := Compare(doc, doc, CompareOptions{}) + if len(diffs) != 0 { + t.Errorf("expected 0 diffs for identical maps, got %d: %v", len(diffs), diffs) + } +} + +func TestCompareOnlyInLeft(t *testing.T) { + left := map[string]any{ + "Name": "MyWorkflow", + "Title": "Hello", + "Extra": "leftonly", + } + right := map[string]any{ + "Name": "MyWorkflow", + "Title": "Hello", + } + diffs := Compare(left, right, CompareOptions{}) + + found := false + for _, d := range diffs { + if d.Path == "Extra" && d.Type == OnlyInLeft { + found = true + } + } + if !found { + t.Errorf("expected OnlyInLeft diff for 'Extra', got: %v", diffs) + } +} + +func TestCompareOnlyInRight(t *testing.T) { + left := map[string]any{ + "Name": "MyWorkflow", + } + right := map[string]any{ + "Name": "MyWorkflow", + "Extra": "rightonly", + } + diffs := Compare(left, right, CompareOptions{}) + + found := false + for _, d := range diffs { + if d.Path == "Extra" && d.Type == OnlyInRight { + found = true + } + } + if !found { + t.Errorf("expected OnlyInRight diff for 'Extra', got: %v", diffs) + } +} + +func TestCompareValueMismatch(t *testing.T) { + left := map[string]any{ + "Title": "Hello", + } + right := map[string]any{ + "Title": "World", + } + diffs := Compare(left, right, CompareOptions{}) + + if len(diffs) != 1 { + t.Fatalf("expected 1 diff, got %d: %v", len(diffs), diffs) + } + if diffs[0].Type != ValueMismatch { + t.Errorf("expected ValueMismatch, got %v", diffs[0].Type) + } + if diffs[0].Path != "Title" { + t.Errorf("expected path 'Title', got %q", diffs[0].Path) + } +} + +func TestCompareSkipsStructural(t *testing.T) { + left := map[string]any{ + "$ID": "abc-123", + "PersistentId": "pid-1", + "RelativeMiddlePoint": map[string]any{"X": 0}, + "Size": map[string]any{"Width": 100}, + "Name": "Same", + } + right := map[string]any{ + "$ID": "xyz-789", + "PersistentId": "pid-2", + "RelativeMiddlePoint": map[string]any{"X": 999}, + "Size": map[string]any{"Width": 200}, + "Name": "Same", + } + + diffs := Compare(left, right, CompareOptions{IncludeAll: false}) + if len(diffs) != 0 { + t.Errorf("expected 0 diffs (structural fields skipped), got %d: %v", len(diffs), diffs) + } +} + +func TestCompareWithAll(t *testing.T) { + left := map[string]any{ + "$ID": "abc-123", + "Name": "Same", + } + right := map[string]any{ + "$ID": "xyz-789", + "Name": "Same", + } + + diffs := Compare(left, right, CompareOptions{IncludeAll: true}) + if len(diffs) != 1 { + t.Fatalf("expected 1 diff ($ID), got %d: %v", len(diffs), diffs) + } + if diffs[0].Path != "$ID" { + t.Errorf("expected path '$ID', got %q", diffs[0].Path) + } +} + +func TestCompareArraySmartMatch(t *testing.T) { + left := map[string]any{ + "Activities": []any{ + map[string]any{"$Type": "Workflows$UserTask", "Name": "Approve", "Caption": "Approve it"}, + map[string]any{"$Type": "Workflows$UserTask", "Name": "Review", "Caption": "Review it"}, + }, + } + right := map[string]any{ + "Activities": []any{ + // Same elements, reversed order, with a caption change + map[string]any{"$Type": "Workflows$UserTask", "Name": "Review", "Caption": "Review updated"}, + map[string]any{"$Type": "Workflows$UserTask", "Name": "Approve", "Caption": "Approve it"}, + }, + } + + diffs := Compare(left, right, CompareOptions{}) + + // Should find exactly 1 diff: Caption change on Review, matched by identity + if len(diffs) != 1 { + t.Fatalf("expected 1 diff (Caption on Review), got %d: %v", len(diffs), diffs) + } + if !strings.Contains(diffs[0].Path, "Review") { + t.Errorf("expected diff path to reference Review, got %q", diffs[0].Path) + } + if diffs[0].Type != ValueMismatch { + t.Errorf("expected ValueMismatch, got %v", diffs[0].Type) + } +} + +func TestCompareArraySmartMatchOnlyInLeft(t *testing.T) { + left := map[string]any{ + "Items": []any{ + map[string]any{"$Type": "T", "Name": "A"}, + map[string]any{"$Type": "T", "Name": "B"}, + }, + } + right := map[string]any{ + "Items": []any{ + map[string]any{"$Type": "T", "Name": "A"}, + }, + } + + diffs := Compare(left, right, CompareOptions{}) + + found := false + for _, d := range diffs { + if d.Type == OnlyInLeft && strings.Contains(d.Path, "B") { + found = true + } + } + if !found { + t.Errorf("expected OnlyInLeft for element B, got: %v", diffs) + } +} + +func TestCompareNestedMaps(t *testing.T) { + left := map[string]any{ + "Outer": map[string]any{ + "Inner": "leftval", + }, + } + right := map[string]any{ + "Outer": map[string]any{ + "Inner": "rightval", + }, + } + + diffs := Compare(left, right, CompareOptions{}) + if len(diffs) != 1 { + t.Fatalf("expected 1 diff, got %d: %v", len(diffs), diffs) + } + if diffs[0].Path != "Outer.Inner" { + t.Errorf("expected path 'Outer.Inner', got %q", diffs[0].Path) + } +} + +func TestFormatDiffsOutput(t *testing.T) { + diffs := []Diff{ + {Path: "Title", Type: ValueMismatch, LeftValue: `"A"`, RightValue: `"B"`}, + {Path: "Extra", Type: OnlyInLeft, LeftValue: `"x"`}, + {Path: "New", Type: OnlyInRight, RightValue: `"y"`}, + } + + output := FormatDiffs(diffs) + if !strings.Contains(output, "Summary: 3 differences") { + t.Errorf("expected summary line, got:\n%s", output) + } + if !strings.Contains(output, "1 only-in-left") { + t.Errorf("expected only-in-left count, got:\n%s", output) + } +} + +func TestFormatDiffsEmpty(t *testing.T) { + output := FormatDiffs(nil) + if output != "No differences found." { + t.Errorf("expected 'No differences found.', got: %q", output) + } +} diff --git a/bson/discover.go b/bson/discover.go new file mode 100644 index 0000000..3237cbc --- /dev/null +++ b/bson/discover.go @@ -0,0 +1,347 @@ +package bson + +import ( + "fmt" + "strings" +) + +// CoverageStatus represents field coverage state. +type CoverageStatus int + +const ( + // Covered means the field value was found in the MDL text. + Covered CoverageStatus = iota + // Uncovered means the field has a non-default value but was not found in the MDL text. + Uncovered + // DefaultValue means the field is empty, null, or false (intentionally omitted from MDL). + DefaultValue + // Unknown means coverage cannot be determined automatically. + Unknown +) + +func (s CoverageStatus) String() string { + switch s { + case Covered: + return "covered" + case Uncovered: + return "UNCOVERED" + case DefaultValue: + return "default" + case Unknown: + return "unknown" + default: + return "?" + } +} + +// RawUnit decouples discover logic from the mpr package. +type RawUnit struct { + QualifiedName string + BsonType string + Fields map[string]any +} + +// FieldCoverage holds coverage info for one field. +type FieldCoverage struct { + StorageName string + GoFieldName string + GoType string + Category FieldCategory + Status CoverageStatus + SampleValue string // short string representation of sample value from BSON +} + +// TypeCoverage holds coverage for one $Type. +type TypeCoverage struct { + BsonType string + InstanceCount int + Fields []FieldCoverage + UnknownFields []string // fields found in BSON but not in TypeRegistry +} + +// SemanticCoverage returns the count of covered and total semantic fields. +func (tc *TypeCoverage) SemanticCoverage() (covered, total int) { + for _, f := range tc.Fields { + if f.Category == Semantic { + total++ + if f.Status == Covered { + covered++ + } + } + } + return covered, total +} + +// DiscoverResult holds complete discover output. +type DiscoverResult struct { + Types []TypeCoverage +} + +// checkFieldCoverage determines if a BSON field value appears in MDL text. +func checkFieldCoverage(storageName string, bsonValue any, mdlText string) CoverageStatus { + switch v := bsonValue.(type) { + case string: + if v == "" { + return DefaultValue + } + if strings.Contains(mdlText, v) { + return Covered + } + return Uncovered + case bool: + if !v { + return DefaultValue + } + if strings.Contains(mdlText, "true") { + return Covered + } + return Uncovered + case nil: + return DefaultValue + case map[string]any: + return checkNestedCoverage(v, mdlText) + default: + return Unknown + } +} + +// checkNestedCoverage checks if any leaf string in a nested object appears in MDL text. +func checkNestedCoverage(obj map[string]any, mdlText string) CoverageStatus { + for _, v := range obj { + switch val := v.(type) { + case string: + if val != "" && strings.Contains(mdlText, val) { + return Covered + } + case map[string]any: + if checkNestedCoverage(val, mdlText) == Covered { + return Covered + } + } + } + return Uncovered +} + +// sampleValueString returns a short string representation of a BSON value for display. +func sampleValueString(v any) string { + switch val := v.(type) { + case nil: + return "null" + case string: + if val == "" { + return `""` + } + if len(val) > 40 { + return fmt.Sprintf("%q", val[:40]+"...") + } + return fmt.Sprintf("%q", val) + case bool: + return fmt.Sprintf("%v", val) + case int32: + return fmt.Sprintf("%d", val) + case int64: + return fmt.Sprintf("%d", val) + case float64: + return fmt.Sprintf("%g", val) + case map[string]any: + if t, ok := val["$Type"]; ok { + return fmt.Sprintf("{$Type: %v}", t) + } + return fmt.Sprintf("{%d fields}", len(val)) + case []any: + return fmt.Sprintf("[%d elements]", len(val)) + default: + s := fmt.Sprintf("%v", val) + if len(s) > 40 { + return s[:40] + "..." + } + return s + } +} + +// RunDiscover analyzes field coverage for BSON objects against MDL text. +// mdlText is optional -- if empty, all non-default fields are marked Uncovered. +func RunDiscover(rawUnits []RawUnit, mdlText string) *DiscoverResult { + // Group raw units by $Type. + typeGroups := make(map[string][]RawUnit) + var typeOrder []string + for _, ru := range rawUnits { + if _, seen := typeGroups[ru.BsonType]; !seen { + typeOrder = append(typeOrder, ru.BsonType) + } + typeGroups[ru.BsonType] = append(typeGroups[ru.BsonType], ru) + } + + var result DiscoverResult + for _, bsonType := range typeOrder { + units := typeGroups[bsonType] + tc := analyzeTypeCoverage(bsonType, units, mdlText) + result.Types = append(result.Types, tc) + } + return &result +} + +// analyzeTypeCoverage builds coverage for a single $Type across all its instances. +func analyzeTypeCoverage(bsonType string, units []RawUnit, mdlText string) TypeCoverage { + tc := TypeCoverage{ + BsonType: bsonType, + InstanceCount: len(units), + } + + // Collect all field names and one sample value across all instances. + fieldSamples := make(map[string]any) + for _, u := range units { + for fieldName, fieldValue := range u.Fields { + if _, exists := fieldSamples[fieldName]; !exists { + fieldSamples[fieldName] = fieldValue + } else if fieldValue != nil { + // Prefer non-nil sample values. + existing := fieldSamples[fieldName] + if existing == nil { + fieldSamples[fieldName] = fieldValue + } + } + } + } + + // Look up metadata from TypeRegistry. + meta := GetFieldMeta(bsonType) + if meta == nil { + // Type not in registry -- report all fields as unknown category. + for fieldName, sample := range fieldSamples { + category := classifyField(fieldName) + tc.Fields = append(tc.Fields, FieldCoverage{ + StorageName: fieldName, + GoFieldName: "", + GoType: "", + Category: category, + Status: checkFieldCoverage(fieldName, sample, mdlText), + SampleValue: sampleValueString(sample), + }) + } + return tc + } + + // Build a case-insensitive lookup from storage name to meta. + // BSON uses PascalCase ("AdminPage") while Go json tags use camelCase ("adminPage"). + metaByStorageLower := make(map[string]PropertyMeta, len(meta)) + for _, m := range meta { + metaByStorageLower[strings.ToLower(m.StorageName)] = m + } + + // Build case-insensitive lookup from BSON field names to sample values. + bsonFieldLower := make(map[string]any, len(fieldSamples)) + for k, v := range fieldSamples { + bsonFieldLower[strings.ToLower(k)] = v + } + + // Process fields from metadata (preserves struct field order). + for _, m := range meta { + sample, inBson := bsonFieldLower[strings.ToLower(m.StorageName)] + status := DefaultValue + if inBson { + status = checkFieldCoverage(m.StorageName, sample, mdlText) + } + tc.Fields = append(tc.Fields, FieldCoverage{ + StorageName: m.StorageName, + GoFieldName: m.GoFieldName, + GoType: m.GoType, + Category: m.Category, + Status: status, + SampleValue: sampleValueString(sample), + }) + } + + // Find fields in BSON but not in metadata. + for fieldName := range fieldSamples { + if _, inMeta := metaByStorageLower[strings.ToLower(fieldName)]; !inMeta { + tc.UnknownFields = append(tc.UnknownFields, fieldName) + } + } + + return tc +} + +// FormatResult formats a DiscoverResult for terminal output. +func FormatResult(dr *DiscoverResult) string { + var sb strings.Builder + for i, tc := range dr.Types { + if i > 0 { + sb.WriteString("\n") + } + formatTypeCoverage(&sb, &tc) + } + return sb.String() +} + +func formatTypeCoverage(sb *strings.Builder, tc *TypeCoverage) { + sb.WriteString(fmt.Sprintf("%s (%d objects scanned)\n", tc.BsonType, tc.InstanceCount)) + + // Separate fields by category. + var semanticFields []FieldCoverage + var structuralNames []string + var layoutNames []string + + for _, f := range tc.Fields { + switch f.Category { + case Semantic: + semanticFields = append(semanticFields, f) + case Structural: + structuralNames = append(structuralNames, f.StorageName) + case Layout: + layoutNames = append(layoutNames, f.StorageName) + } + } + + // Print semantic fields. + for _, f := range semanticFields { + marker := "\u2717" // ✗ + if f.Status == Covered { + marker = "\u2713" // ✓ + } + detail := f.Status.String() + if f.Status == Uncovered { + detail = fmt.Sprintf("UNCOVERED (%s, ex: %s)", typeLabel(f.GoType), f.SampleValue) + } + sb.WriteString(fmt.Sprintf(" %s %-30s %s\n", marker, f.StorageName, detail)) + } + + // Print structural/layout summary. + nonSemanticCount := len(structuralNames) + len(layoutNames) + if nonSemanticCount > 0 { + allNames := append(structuralNames, layoutNames...) + if len(allNames) <= 5 { + sb.WriteString(fmt.Sprintf(" - %s structural/layout (%d fields)\n", + strings.Join(allNames, ", "), nonSemanticCount)) + } else { + preview := strings.Join(allNames[:3], ", ") + sb.WriteString(fmt.Sprintf(" - %s... structural/layout (%d fields)\n", + preview, nonSemanticCount)) + } + } + + // Print unknown fields. + if len(tc.UnknownFields) > 0 { + sb.WriteString(fmt.Sprintf(" ? unknown-to-schema: %s\n", strings.Join(tc.UnknownFields, ", "))) + } + + // Coverage summary. + covered, total := tc.SemanticCoverage() + pct := 0 + if total > 0 { + pct = covered * 100 / total + } + sb.WriteString(fmt.Sprintf("\n Coverage: %d/%d semantic fields (%d%%)\n", covered, total, pct)) +} + +// typeLabel returns a short label for a Go type string. +func typeLabel(goType string) string { + if goType == "" { + return "any" + } + // Strip package prefix for readability. + if idx := strings.LastIndex(goType, "."); idx >= 0 { + return goType[idx+1:] + } + return goType +} diff --git a/bson/discover_test.go b/bson/discover_test.go new file mode 100644 index 0000000..24de912 --- /dev/null +++ b/bson/discover_test.go @@ -0,0 +1,363 @@ +package bson + +import ( + "strings" + "testing" +) + +func TestCheckFieldCoverage_StringValues(t *testing.T) { + tests := []struct { + name string + value any + mdlText string + expected CoverageStatus + }{ + { + name: "empty string is default", + value: "", + mdlText: "anything", + expected: DefaultValue, + }, + { + name: "string found in MDL", + value: "MyWorkflow", + mdlText: "CREATE WORKFLOW MyWorkflow BEGIN END", + expected: Covered, + }, + { + name: "string not found in MDL", + value: "HiddenTitle", + mdlText: "CREATE WORKFLOW MyWorkflow BEGIN END", + expected: Uncovered, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := checkFieldCoverage("TestField", tt.value, tt.mdlText) + if got != tt.expected { + t.Errorf("checkFieldCoverage(%q, %v, ...) = %v, want %v", + "TestField", tt.value, got, tt.expected) + } + }) + } +} + +func TestCheckFieldCoverage_BoolValues(t *testing.T) { + tests := []struct { + name string + value bool + mdlText string + expected CoverageStatus + }{ + { + name: "false is default", + value: false, + mdlText: "anything", + expected: DefaultValue, + }, + { + name: "true found in MDL", + value: true, + mdlText: "SET flag = true", + expected: Covered, + }, + { + name: "true not found in MDL", + value: true, + mdlText: "CREATE WORKFLOW BEGIN END", + expected: Uncovered, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := checkFieldCoverage("TestField", tt.value, tt.mdlText) + if got != tt.expected { + t.Errorf("checkFieldCoverage(%q, %v, ...) = %v, want %v", + "TestField", tt.value, got, tt.expected) + } + }) + } +} + +func TestCheckFieldCoverage_NilValue(t *testing.T) { + got := checkFieldCoverage("NullField", nil, "anything") + if got != DefaultValue { + t.Errorf("checkFieldCoverage with nil = %v, want DefaultValue", got) + } +} + +func TestCheckFieldCoverage_UnknownTypes(t *testing.T) { + // int32 should return Unknown since we don't handle it in the main switch + got := checkFieldCoverage("IntField", int32(42), "42") + if got != Unknown { + t.Errorf("checkFieldCoverage with int32 = %v, want Unknown", got) + } +} + +func TestCheckFieldCoverage_NestedObject(t *testing.T) { + tests := []struct { + name string + value map[string]any + mdlText string + expected CoverageStatus + }{ + { + name: "leaf string found in MDL", + value: map[string]any{ + "$Type": "Workflows$XPathUserTargeting", + "XPath": "[Module.MyEntity]", + }, + mdlText: "TARGETING [Module.MyEntity]", + expected: Covered, + }, + { + name: "no leaf strings found", + value: map[string]any{ + "$Type": "Workflows$NoEvent", + "$ID": "abc-123", + }, + mdlText: "CREATE WORKFLOW BEGIN END", + expected: Uncovered, + }, + { + name: "deeply nested string found", + value: map[string]any{ + "Outer": map[string]any{ + "Inner": "DeepValue", + }, + }, + mdlText: "DeepValue is here", + expected: Covered, + }, + { + name: "all empty strings", + value: map[string]any{ + "Field1": "", + "Field2": "", + }, + mdlText: "anything", + expected: Uncovered, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := checkFieldCoverage("NestedField", tt.value, tt.mdlText) + if got != tt.expected { + t.Errorf("checkFieldCoverage(%q, nested, ...) = %v, want %v", + "NestedField", got, tt.expected) + } + }) + } +} + +func TestRunDiscover_BasicCoverage(t *testing.T) { + units := []RawUnit{ + { + QualifiedName: "Module.Wf1", + BsonType: "TestType$Foo", + Fields: map[string]any{ + "Name": "Wf1", + "Title": "My Workflow", + "Enabled": true, + "Notes": "", + "Extra": nil, + }, + }, + } + + mdlText := "CREATE WORKFLOW Wf1 BEGIN END" + + dr := RunDiscover(units, mdlText) + if dr == nil { + t.Fatal("RunDiscover returned nil") + } + if len(dr.Types) != 1 { + t.Fatalf("expected 1 type, got %d", len(dr.Types)) + } + + tc := dr.Types[0] + if tc.BsonType != "TestType$Foo" { + t.Errorf("BsonType = %q, want TestType$Foo", tc.BsonType) + } + if tc.InstanceCount != 1 { + t.Errorf("InstanceCount = %d, want 1", tc.InstanceCount) + } + + // Since TestType$Foo is not in TypeRegistry, all fields are reported directly. + statusByField := make(map[string]CoverageStatus) + for _, f := range tc.Fields { + statusByField[f.StorageName] = f.Status + } + + if statusByField["Name"] != Covered { + t.Errorf("Name should be Covered, got %v", statusByField["Name"]) + } + if statusByField["Title"] != Uncovered { + t.Errorf("Title should be Uncovered, got %v", statusByField["Title"]) + } + if statusByField["Notes"] != DefaultValue { + t.Errorf("Notes (empty string) should be DefaultValue, got %v", statusByField["Notes"]) + } + if statusByField["Extra"] != DefaultValue { + t.Errorf("Extra (nil) should be DefaultValue, got %v", statusByField["Extra"]) + } +} + +func TestRunDiscover_MultipleInstances(t *testing.T) { + units := []RawUnit{ + { + QualifiedName: "M.A", + BsonType: "TestType$Bar", + Fields: map[string]any{ + "Name": "A", + "Color": nil, + }, + }, + { + QualifiedName: "M.B", + BsonType: "TestType$Bar", + Fields: map[string]any{ + "Name": "B", + "Color": "red", + }, + }, + } + + dr := RunDiscover(units, "A B") + if len(dr.Types) != 1 { + t.Fatalf("expected 1 type, got %d", len(dr.Types)) + } + + tc := dr.Types[0] + if tc.InstanceCount != 2 { + t.Errorf("InstanceCount = %d, want 2", tc.InstanceCount) + } + + // Color should prefer the non-nil sample ("red"). + for _, f := range tc.Fields { + if f.StorageName == "Color" { + if f.SampleValue != `"red"` { + t.Errorf("Color SampleValue = %q, want %q", f.SampleValue, `"red"`) + } + } + } +} + +func TestRunDiscover_MultipleTypes(t *testing.T) { + units := []RawUnit{ + {BsonType: "TypeA$X", Fields: map[string]any{"A": "val"}}, + {BsonType: "TypeB$Y", Fields: map[string]any{"B": "val"}}, + } + + dr := RunDiscover(units, "val") + if len(dr.Types) != 2 { + t.Fatalf("expected 2 types, got %d", len(dr.Types)) + } + if dr.Types[0].BsonType != "TypeA$X" { + t.Errorf("first type = %q, want TypeA$X", dr.Types[0].BsonType) + } + if dr.Types[1].BsonType != "TypeB$Y" { + t.Errorf("second type = %q, want TypeB$Y", dr.Types[1].BsonType) + } +} + +func TestRunDiscover_EmptyMDLText(t *testing.T) { + units := []RawUnit{ + { + BsonType: "TestType$Empty", + Fields: map[string]any{ + "Name": "Something", + "Empty": "", + }, + }, + } + + dr := RunDiscover(units, "") + tc := dr.Types[0] + + statusByField := make(map[string]CoverageStatus) + for _, f := range tc.Fields { + statusByField[f.StorageName] = f.Status + } + + if statusByField["Name"] != Uncovered { + t.Errorf("Name with empty MDL should be Uncovered, got %v", statusByField["Name"]) + } + if statusByField["Empty"] != DefaultValue { + t.Errorf("Empty string should still be DefaultValue, got %v", statusByField["Empty"]) + } +} + +func TestFormatResult(t *testing.T) { + dr := &DiscoverResult{ + Types: []TypeCoverage{ + { + BsonType: "Test$Widget", + InstanceCount: 3, + Fields: []FieldCoverage{ + {StorageName: "Name", Category: Semantic, Status: Covered}, + {StorageName: "Title", GoType: "string", Category: Semantic, Status: Uncovered, SampleValue: `"hello"`}, + {StorageName: "$ID", Category: Structural, Status: DefaultValue}, + {StorageName: "$Type", Category: Structural, Status: DefaultValue}, + }, + }, + }, + } + + output := FormatResult(dr) + + if !strings.Contains(output, "Test$Widget (3 objects scanned)") { + t.Errorf("output missing type header: %s", output) + } + if !strings.Contains(output, "Coverage: 1/2 semantic fields (50%)") { + t.Errorf("output missing coverage summary: %s", output) + } + if !strings.Contains(output, "UNCOVERED") { + t.Errorf("output missing UNCOVERED marker: %s", output) + } +} + +func TestSampleValueString(t *testing.T) { + tests := []struct { + name string + value any + expected string + }{ + {"nil", nil, "null"}, + {"empty string", "", `""`}, + {"short string", "hello", `"hello"`}, + {"bool true", true, "true"}, + {"bool false", false, "false"}, + {"int32", int32(42), "42"}, + {"slice", []any{1, 2, 3}, "[3 elements]"}, + {"map with $Type", map[string]any{"$Type": "Foo"}, "{$Type: Foo}"}, + {"map without $Type", map[string]any{"a": 1, "b": 2}, "{2 fields}"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := sampleValueString(tt.value) + if got != tt.expected { + t.Errorf("sampleValueString(%v) = %q, want %q", tt.value, got, tt.expected) + } + }) + } +} + +func TestCoverageStatusString(t *testing.T) { + if Covered.String() != "covered" { + t.Errorf("Covered.String() = %q", Covered.String()) + } + if Uncovered.String() != "UNCOVERED" { + t.Errorf("Uncovered.String() = %q", Uncovered.String()) + } + if DefaultValue.String() != "default" { + t.Errorf("DefaultValue.String() = %q", DefaultValue.String()) + } + if Unknown.String() != "unknown" { + t.Errorf("Unknown.String() = %q", Unknown.String()) + } +} diff --git a/bson/registry.go b/bson/registry.go new file mode 100644 index 0000000..7285bd9 --- /dev/null +++ b/bson/registry.go @@ -0,0 +1,125 @@ +// Package bson provides BSON inspection and field coverage analysis utilities +// for Mendix project files. +package bson + +import ( + "reflect" + "strings" + + "github.com/mendixlabs/mxcli/generated/metamodel" +) + +// TypeRegistry maps BSON $Type strings to Go reflect.Type for all Workflows$ structs. +var TypeRegistry = map[string]reflect.Type{ + "Workflows$AbsoluteAmountUserInput": reflect.TypeOf(metamodel.WorkflowsAbsoluteAmountUserInput{}), + "Workflows$AllUserInput": reflect.TypeOf(metamodel.WorkflowsAllUserInput{}), + "Workflows$Annotation": reflect.TypeOf(metamodel.WorkflowsAnnotation{}), + "Workflows$BezierCurve": reflect.TypeOf(metamodel.WorkflowsBezierCurve{}), + "Workflows$BooleanCase": reflect.TypeOf(metamodel.WorkflowsBooleanCase{}), + "Workflows$BooleanConditionOutcome": reflect.TypeOf(metamodel.WorkflowsBooleanConditionOutcome{}), + "Workflows$CallMicroflowTask": reflect.TypeOf(metamodel.WorkflowsCallMicroflowTask{}), + "Workflows$CallWorkflowActivity": reflect.TypeOf(metamodel.WorkflowsCallWorkflowActivity{}), + "Workflows$ConsensusCompletionCriteria": reflect.TypeOf(metamodel.WorkflowsConsensusCompletionCriteria{}), + "Workflows$EndOfBoundaryEventPathActivity": reflect.TypeOf(metamodel.WorkflowsEndOfBoundaryEventPathActivity{}), + "Workflows$EndOfParallelSplitPathActivity": reflect.TypeOf(metamodel.WorkflowsEndOfParallelSplitPathActivity{}), + "Workflows$EndWorkflowActivity": reflect.TypeOf(metamodel.WorkflowsEndWorkflowActivity{}), + "Workflows$EnumerationValueConditionOutcome": reflect.TypeOf(metamodel.WorkflowsEnumerationValueConditionOutcome{}), + "Workflows$ExclusiveSplitActivity": reflect.TypeOf(metamodel.WorkflowsExclusiveSplitActivity{}), + "Workflows$FloatingAnnotation": reflect.TypeOf(metamodel.WorkflowsFloatingAnnotation{}), + "Workflows$Flow": reflect.TypeOf(metamodel.WorkflowsFlow{}), + "Workflows$FlowLine": reflect.TypeOf(metamodel.WorkflowsFlowLine{}), + "Workflows$InterruptingTimerBoundaryEvent": reflect.TypeOf(metamodel.WorkflowsInterruptingTimerBoundaryEvent{}), + "Workflows$JumpToActivity": reflect.TypeOf(metamodel.WorkflowsJumpToActivity{}), + "Workflows$LinearRecurrence": reflect.TypeOf(metamodel.WorkflowsLinearRecurrence{}), + "Workflows$MajorityCompletionCriteria": reflect.TypeOf(metamodel.WorkflowsMajorityCompletionCriteria{}), + "Workflows$MergeActivity": reflect.TypeOf(metamodel.WorkflowsMergeActivity{}), + "Workflows$MicroflowBasedEvent": reflect.TypeOf(metamodel.WorkflowsMicroflowBasedEvent{}), + "Workflows$MicroflowCallParameterMapping": reflect.TypeOf(metamodel.WorkflowsMicroflowCallParameterMapping{}), + "Workflows$MicroflowCompletionCriteria": reflect.TypeOf(metamodel.WorkflowsMicroflowCompletionCriteria{}), + "Workflows$MicroflowEventHandler": reflect.TypeOf(metamodel.WorkflowsMicroflowEventHandler{}), + "Workflows$MicroflowGroupTargeting": reflect.TypeOf(metamodel.WorkflowsMicroflowGroupTargeting{}), + "Workflows$MicroflowUserTargeting": reflect.TypeOf(metamodel.WorkflowsMicroflowUserTargeting{}), + "Workflows$MultiUserTaskActivity": reflect.TypeOf(metamodel.WorkflowsMultiUserTaskActivity{}), + "Workflows$NoEvent": reflect.TypeOf(metamodel.WorkflowsNoEvent{}), + "Workflows$NoUserTargeting": reflect.TypeOf(metamodel.WorkflowsNoUserTargeting{}), + "Workflows$NonInterruptingTimerBoundaryEvent": reflect.TypeOf(metamodel.WorkflowsNonInterruptingTimerBoundaryEvent{}), + "Workflows$OrthogonalPath": reflect.TypeOf(metamodel.WorkflowsOrthogonalPath{}), + "Workflows$PageParameterMapping": reflect.TypeOf(metamodel.WorkflowsPageParameterMapping{}), + "Workflows$PageReference": reflect.TypeOf(metamodel.WorkflowsPageReference{}), + "Workflows$ParallelSplitActivity": reflect.TypeOf(metamodel.WorkflowsParallelSplitActivity{}), + "Workflows$ParallelSplitOutcome": reflect.TypeOf(metamodel.WorkflowsParallelSplitOutcome{}), + "Workflows$Parameter": reflect.TypeOf(metamodel.WorkflowsParameter{}), + "Workflows$PercentageAmountUserInput": reflect.TypeOf(metamodel.WorkflowsPercentageAmountUserInput{}), + "Workflows$SingleUserTaskActivity": reflect.TypeOf(metamodel.WorkflowsSingleUserTaskActivity{}), + "Workflows$StartWorkflowActivity": reflect.TypeOf(metamodel.WorkflowsStartWorkflowActivity{}), + "Workflows$StringCase": reflect.TypeOf(metamodel.WorkflowsStringCase{}), + "Workflows$ThresholdCompletionCriteria": reflect.TypeOf(metamodel.WorkflowsThresholdCompletionCriteria{}), + "Workflows$UserTaskOutcome": reflect.TypeOf(metamodel.WorkflowsUserTaskOutcome{}), + "Workflows$VetoCompletionCriteria": reflect.TypeOf(metamodel.WorkflowsVetoCompletionCriteria{}), + "Workflows$VoidCase": reflect.TypeOf(metamodel.WorkflowsVoidCase{}), + "Workflows$VoidConditionOutcome": reflect.TypeOf(metamodel.WorkflowsVoidConditionOutcome{}), + "Workflows$WaitForNotificationActivity": reflect.TypeOf(metamodel.WorkflowsWaitForNotificationActivity{}), + "Workflows$WaitForTimerActivity": reflect.TypeOf(metamodel.WorkflowsWaitForTimerActivity{}), + "Workflows$Workflow": reflect.TypeOf(metamodel.WorkflowsWorkflow{}), + "Workflows$WorkflowCallParameterMapping": reflect.TypeOf(metamodel.WorkflowsWorkflowCallParameterMapping{}), + "Workflows$WorkflowDefinitionNameSelection": reflect.TypeOf(metamodel.WorkflowsWorkflowDefinitionNameSelection{}), + "Workflows$WorkflowDefinitionObjectSelection": reflect.TypeOf(metamodel.WorkflowsWorkflowDefinitionObjectSelection{}), + "Workflows$WorkflowEventHandler": reflect.TypeOf(metamodel.WorkflowsWorkflowEventHandler{}), + "Workflows$WorkflowMetaData": reflect.TypeOf(metamodel.WorkflowsWorkflowMetaData{}), + "Workflows$XPathGroupTargeting": reflect.TypeOf(metamodel.WorkflowsXPathGroupTargeting{}), + "Workflows$XPathUserTargeting": reflect.TypeOf(metamodel.WorkflowsXPathUserTargeting{}), +} + +// PropertyMeta describes a single field's metadata derived from reflection. +type PropertyMeta struct { + GoFieldName string + StorageName string // from json tag + GoType string + IsList bool + IsPointer bool + IsRequired bool // json tag lacks "omitempty" + Category FieldCategory +} + +// GetFieldMeta returns all field metadata for a given BSON $Type string. +// Returns nil if the type is not found in TypeRegistry. +func GetFieldMeta(bsonType string) []PropertyMeta { + rt, ok := TypeRegistry[bsonType] + if !ok { + return nil + } + + var fields []PropertyMeta + for i := 0; i < rt.NumField(); i++ { + f := rt.Field(i) + if f.Anonymous { + continue // skip embedded BaseElement + } + + jsonTag := f.Tag.Get("json") + storageName, ok := parseJSONTag(jsonTag) + if !ok { + continue + } + isRequired := !strings.Contains(jsonTag, "omitempty") + + fields = append(fields, PropertyMeta{ + GoFieldName: f.Name, + StorageName: storageName, + GoType: f.Type.String(), + IsList: f.Type.Kind() == reflect.Slice, + IsPointer: f.Type.Kind() == reflect.Ptr, + IsRequired: isRequired, + Category: classifyField(storageName), + }) + } + return fields +} + +func parseJSONTag(tag string) (string, bool) { + if tag == "" || tag == "-" { + return "", false + } + name, _, _ := strings.Cut(tag, ",") + return name, true +} diff --git a/bson/registry_test.go b/bson/registry_test.go new file mode 100644 index 0000000..2b335eb --- /dev/null +++ b/bson/registry_test.go @@ -0,0 +1,79 @@ +package bson + +import ( + "testing" +) + +func TestTypeRegistryHasEntries(t *testing.T) { + if len(TypeRegistry) == 0 { + t.Fatal("TypeRegistry is empty, expected Workflows$ entries") + } + t.Logf("TypeRegistry contains %d entries", len(TypeRegistry)) +} + +func TestGetFieldMetaWorkflowsWorkflow(t *testing.T) { + fields := GetFieldMeta("Workflows$Workflow") + if fields == nil { + t.Fatal("GetFieldMeta returned nil for Workflows$Workflow") + } + if len(fields) == 0 { + t.Fatal("GetFieldMeta returned empty fields for Workflows$Workflow") + } + + fieldByStorage := make(map[string]PropertyMeta) + for _, f := range fields { + fieldByStorage[f.StorageName] = f + } + + // Verify expected semantic fields exist (json tags use lowercase) + expectedFields := []string{"name", "flow", "parameter"} + for _, name := range expectedFields { + if _, ok := fieldByStorage[name]; !ok { + t.Errorf("expected field %q not found in Workflows$Workflow metadata", name) + } + } + + // Verify name field properties + nameField, ok := fieldByStorage["name"] + if ok { + if nameField.GoType != "string" { + t.Errorf("name field GoType = %q, want %q", nameField.GoType, "string") + } + if nameField.Category != Semantic { + t.Errorf("name field Category = %v, want Semantic", nameField.Category) + } + if nameField.GoFieldName != "Name" { + t.Errorf("name field GoFieldName = %q, want %q", nameField.GoFieldName, "Name") + } + } +} + +func TestGetFieldMetaUnknownType(t *testing.T) { + fields := GetFieldMeta("Nonexistent$Type") + if fields != nil { + t.Errorf("expected nil for unknown type, got %d fields", len(fields)) + } +} + +func TestClassifyField(t *testing.T) { + tests := []struct { + storageName string + want FieldCategory + }{ + {"$ID", Structural}, + {"$Type", Structural}, + {"PersistentId", Structural}, + {"RelativeMiddlePoint", Layout}, + {"Size", Layout}, + {"Name", Semantic}, + {"Flow", Semantic}, + {"Expression", Semantic}, + } + + for _, tc := range tests { + got := classifyField(tc.storageName) + if got != tc.want { + t.Errorf("classifyField(%q) = %v, want %v", tc.storageName, got, tc.want) + } + } +} diff --git a/bson/render.go b/bson/render.go new file mode 100644 index 0000000..f9baf4d --- /dev/null +++ b/bson/render.go @@ -0,0 +1,150 @@ +package bson + +import ( + "fmt" + "sort" + "strings" + + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" +) + +// Render converts a bson.D document to Normalized DSL text. +// indent is the base indentation level (0 for top-level). +func Render(doc bson.D, indent int) string { + var sb strings.Builder + renderDoc(&sb, doc, indent) + return strings.TrimRight(sb.String(), "\n") +} + +func renderDoc(sb *strings.Builder, doc bson.D, indent int) { + pad := strings.Repeat(" ", indent) + + // Extract $Type for header + typeName := "" + for _, e := range doc { + if e.Key == "$Type" { + typeName, _ = e.Value.(string) + break + } + } + if typeName != "" { + sb.WriteString(pad + typeName + "\n") + } + + renderFields(sb, doc, indent+1) +} + +// renderFields renders only the non-structural fields of a doc, sorted alphabetically. +// Unlike renderDoc, it does not print the $Type header line. +func renderFields(sb *strings.Builder, doc bson.D, indent int) { + type field struct { + key string + val any + } + var fields []field + for _, e := range doc { + if e.Key == "$ID" || e.Key == "$Type" { + continue + } + fields = append(fields, field{e.Key, e.Value}) + } + sort.Slice(fields, func(i, j int) bool { + return fields[i].key < fields[j].key + }) + + for _, f := range fields { + renderField(sb, f.key, f.val, indent) + } +} + +func renderField(sb *strings.Builder, key string, val any, indent int) { + pad := strings.Repeat(" ", indent) + + switch v := val.(type) { + case nil: + fmt.Fprintf(sb, "%s%s: null\n", pad, key) + + case primitive.Binary: + fmt.Fprintf(sb, "%s%s: \n", pad, key) + + case bson.D: + typeName := "" + for _, e := range v { + if e.Key == "$Type" { + typeName, _ = e.Value.(string) + break + } + } + if typeName != "" { + fmt.Fprintf(sb, "%s%s: %s\n", pad, key, typeName) + } else { + fmt.Fprintf(sb, "%s%s:\n", pad, key) + } + renderFields(sb, v, indent+1) + + case bson.A: + renderArray(sb, key, v, indent) + + case string: + fmt.Fprintf(sb, "%s%s: %q\n", pad, key, v) + + case bool: + fmt.Fprintf(sb, "%s%s: %v\n", pad, key, v) + + default: + fmt.Fprintf(sb, "%s%s: %v\n", pad, key, v) + } +} + +func renderArray(sb *strings.Builder, key string, arr bson.A, indent int) { + pad := strings.Repeat(" ", indent) + + // Check for array marker (first element is int32) + markerStr := "" + startIdx := 0 + if len(arr) > 0 { + if marker, ok := arr[0].(int32); ok { + markerStr = fmt.Sprintf(" [marker=%d]", marker) + startIdx = 1 + } + } + + elements := arr[startIdx:] + if len(elements) == 0 { + fmt.Fprintf(sb, "%s%s%s: []\n", pad, key, markerStr) + return + } + + fmt.Fprintf(sb, "%s%s%s:\n", pad, key, markerStr) + for _, elem := range elements { + renderArrayElement(sb, elem, indent+1) + } +} + +func renderArrayElement(sb *strings.Builder, elem any, indent int) { + pad := strings.Repeat(" ", indent) + + switch v := elem.(type) { + case bson.D: + typeName := "" + for _, e := range v { + if e.Key == "$Type" { + typeName, _ = e.Value.(string) + break + } + } + if typeName != "" { + fmt.Fprintf(sb, "%s- %s\n", pad, typeName) + } else { + fmt.Fprintf(sb, "%s-\n", pad) + } + renderFields(sb, v, indent+2) + + case string: + fmt.Fprintf(sb, "%s- %q\n", pad, v) + + default: + fmt.Fprintf(sb, "%s- %v\n", pad, elem) + } +} diff --git a/bson/render_test.go b/bson/render_test.go new file mode 100644 index 0000000..e1d05de --- /dev/null +++ b/bson/render_test.go @@ -0,0 +1,70 @@ +package bson + +import ( + "testing" + + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" +) + +func TestRenderScalarFields(t *testing.T) { + doc := bson.D{ + {Key: "$Type", Value: "Workflows$Workflow"}, + {Key: "Name", Value: "TestWf"}, + {Key: "Excluded", Value: false}, + {Key: "AdminPage", Value: nil}, + } + got := Render(doc, 0) + want := `Workflows$Workflow + AdminPage: null + Excluded: false + Name: "TestWf"` + if got != want { + t.Errorf("got:\n%s\nwant:\n%s", got, want) + } +} + +func TestRenderUUIDNormalized(t *testing.T) { + doc := bson.D{ + {Key: "$Type", Value: "Workflows$Flow"}, + {Key: "$ID", Value: primitive.Binary{Subtype: 3, Data: []byte("anything")}}, + {Key: "PersistentId", Value: primitive.Binary{Subtype: 3, Data: []byte("anything")}}, + } + got := Render(doc, 0) + want := `Workflows$Flow + PersistentId: ` + if got != want { + t.Errorf("got:\n%s\nwant:\n%s", got, want) + } +} + +func TestRenderArrayWithMarker(t *testing.T) { + doc := bson.D{ + {Key: "$Type", Value: "Workflows$Flow"}, + {Key: "Activities", Value: bson.A{int32(3), bson.D{ + {Key: "$Type", Value: "Workflows$EndWorkflowActivity"}, + {Key: "Name", Value: "end1"}, + }}}, + } + got := Render(doc, 0) + want := `Workflows$Flow + Activities [marker=3]: + - Workflows$EndWorkflowActivity + Name: "end1"` + if got != want { + t.Errorf("got:\n%s\nwant:\n%s", got, want) + } +} + +func TestRenderEmptyArray(t *testing.T) { + doc := bson.D{ + {Key: "$Type", Value: "Workflows$StartWorkflowActivity"}, + {Key: "BoundaryEvents", Value: bson.A{int32(2)}}, + } + got := Render(doc, 0) + want := `Workflows$StartWorkflowActivity + BoundaryEvents [marker=2]: []` + if got != want { + t.Errorf("got:\n%s\nwant:\n%s", got, want) + } +} diff --git a/cmd/mxcli/cmd_bson.go b/cmd/mxcli/cmd_bson.go new file mode 100644 index 0000000..0936ae0 --- /dev/null +++ b/cmd/mxcli/cmd_bson.go @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: Apache-2.0 + +package main + +import "github.com/spf13/cobra" + +var bsonCmd = &cobra.Command{ + Use: "bson", + Short: "BSON inspection and analysis tools", + Long: `Tools for analyzing, comparing, and discovering BSON field coverage +in Mendix project files. + +Subcommands: + dump Dump raw BSON data as JSON or NDSL + discover Analyze field coverage per $Type + compare Diff two BSON objects`, +} + +func init() { + rootCmd.AddCommand(bsonCmd) + + // Register subcommands + bsonCmd.AddCommand(bsonDumpCmd) + bsonCmd.AddCommand(discoverCmd) + bsonCmd.AddCommand(bsonCompareCmd) +} diff --git a/cmd/mxcli/cmd_bson_compare.go b/cmd/mxcli/cmd_bson_compare.go new file mode 100644 index 0000000..685b681 --- /dev/null +++ b/cmd/mxcli/cmd_bson_compare.go @@ -0,0 +1,158 @@ +package main + +import ( + "fmt" + "os" + + bsondebug "github.com/mendixlabs/mxcli/bson" + "github.com/mendixlabs/mxcli/sdk/mpr" + "github.com/spf13/cobra" + "go.mongodb.org/mongo-driver/bson" +) + +var bsonCompareCmd = &cobra.Command{ + Use: "compare [name1] [name2]", + Short: "Compare two BSON objects for differences", + Long: `Compare two BSON objects from Mendix projects and display a structured diff. + +Supports same-project and cross-project comparison. By default, structural +and layout fields ($ID, PersistentId, RelativeMiddlePoint, Size) are skipped. + +Examples: + # Compare two workflows in the same project + mxcli bson compare -p app.mpr --type workflow WF1 WF2 + + # Compare same workflow across two MPR files + mxcli bson compare -p app.mpr -p2 other.mpr --type workflow MyWorkflow + + # Include structural fields in comparison + mxcli bson compare -p app.mpr --type workflow --all WF1 WF2 +`, + Args: cobra.RangeArgs(1, 2), + Run: runBsonCompare, +} + +func init() { + bsonCompareCmd.Flags().StringP("project", "p", "", "Path to first MPR project (required)") + bsonCompareCmd.Flags().String("p2", "", "Path to second MPR project (for cross-MPR comparison)") + bsonCompareCmd.Flags().String("type", "workflow", "Object type: workflow, page, microflow, nanoflow, enumeration, snippet, layout") + bsonCompareCmd.Flags().Bool("all", false, "Include structural/layout fields ($ID, PersistentId, etc.)") + bsonCompareCmd.Flags().String("format", "diff", "Output format: diff, ndsl") +} + +func runBsonCompare(cmd *cobra.Command, args []string) { + projectPath, _ := cmd.Flags().GetString("project") + secondProject, _ := cmd.Flags().GetString("p2") + objectType, _ := cmd.Flags().GetString("type") + includeAll, _ := cmd.Flags().GetBool("all") + + if projectPath == "" { + fmt.Fprintln(os.Stderr, "Error: --project (-p) is required") + os.Exit(1) + } + + reader1, err := mpr.Open(projectPath) + if err != nil { + fmt.Fprintf(os.Stderr, "Error opening project: %v\n", err) + os.Exit(1) + } + defer reader1.Close() + + var leftName, rightName string + var reader2 *mpr.Reader + + switch len(args) { + case 2: + // Two names in the same (or different) project + leftName = args[0] + rightName = args[1] + if secondProject != "" { + reader2, err = mpr.Open(secondProject) + if err != nil { + fmt.Fprintf(os.Stderr, "Error opening second project: %v\n", err) + os.Exit(1) + } + defer reader2.Close() + } + case 1: + // One name, must have -p2 for cross-MPR comparison + if secondProject == "" { + fmt.Fprintln(os.Stderr, "Error: provide two names, or one name with -p2 for cross-MPR comparison") + os.Exit(1) + } + leftName = args[0] + rightName = args[0] + reader2, err = mpr.Open(secondProject) + if err != nil { + fmt.Fprintf(os.Stderr, "Error opening second project: %v\n", err) + os.Exit(1) + } + defer reader2.Close() + } + + // If no second reader, use the first for both + rightReader := reader1 + if reader2 != nil { + rightReader = reader2 + } + + // Fetch raw BSON + leftUnit, err := reader1.GetRawUnitByName(objectType, leftName) + if err != nil { + fmt.Fprintf(os.Stderr, "Error getting %s: %v\n", leftName, err) + os.Exit(1) + } + + rightUnit, err := rightReader.GetRawUnitByName(objectType, rightName) + if err != nil { + fmt.Fprintf(os.Stderr, "Error getting %s: %v\n", rightName, err) + os.Exit(1) + } + + // NDSL format: render both sides as normalized DSL for LLM-friendly comparison + format, _ := cmd.Flags().GetString("format") + if format == "ndsl" { + var leftDocD, rightDocD bson.D + if err := bson.Unmarshal(leftUnit.Contents, &leftDocD); err != nil { + fmt.Fprintf(os.Stderr, "Error parsing BSON for %s: %v\n", leftName, err) + os.Exit(1) + } + if err := bson.Unmarshal(rightUnit.Contents, &rightDocD); err != nil { + fmt.Fprintf(os.Stderr, "Error parsing BSON for %s: %v\n", rightName, err) + os.Exit(1) + } + fmt.Printf("=== LEFT: %s ===\n%s\n\n=== RIGHT: %s ===\n%s\n", + leftName, bsondebug.Render(leftDocD, 0), + rightName, bsondebug.Render(rightDocD, 0)) + return + } + + // Unmarshal to map[string]any + var leftDoc, rightDoc bson.M + if err := bson.Unmarshal(leftUnit.Contents, &leftDoc); err != nil { + fmt.Fprintf(os.Stderr, "Error parsing BSON for %s: %v\n", leftName, err) + os.Exit(1) + } + if err := bson.Unmarshal(rightUnit.Contents, &rightDoc); err != nil { + fmt.Fprintf(os.Stderr, "Error parsing BSON for %s: %v\n", rightName, err) + os.Exit(1) + } + + // Compare + opts := bsondebug.CompareOptions{IncludeAll: includeAll} + diffs := bsondebug.Compare(leftDoc, rightDoc, opts) + + // Print header + typeName := leftDoc["$Type"] + if typeName != nil { + fmt.Println(typeName) + } + if leftName == rightName { + fmt.Printf(" Comparing: %s (across two MPRs)\n\n", leftName) + } else { + fmt.Printf(" Comparing: %s vs %s\n\n", leftName, rightName) + } + + // Print formatted output + fmt.Println(bsondebug.FormatDiffs(diffs)) +} diff --git a/cmd/mxcli/cmd_bson_discover.go b/cmd/mxcli/cmd_bson_discover.go new file mode 100644 index 0000000..458e5ec --- /dev/null +++ b/cmd/mxcli/cmd_bson_discover.go @@ -0,0 +1,141 @@ +package main + +import ( + "fmt" + "os" + + bsondiscover "github.com/mendixlabs/mxcli/bson" + "github.com/mendixlabs/mxcli/sdk/mpr" + "github.com/spf13/cobra" + "go.mongodb.org/mongo-driver/bson" +) + +// discoverCmd is the "bson discover" subcommand for field coverage analysis. +// The parent bsonCmd (cmd_bson.go) adds this via bsonCmd.AddCommand(discoverCmd). +var discoverCmd = &cobra.Command{ + Use: "discover", + Short: "Analyze BSON field coverage against MDL output", + Long: `Discover which BSON fields are covered by MDL DESCRIBE output. + +Scans all objects of the given type from the MPR, collects field names and values, +and checks which fields appear in MDL text output. Reports per-$Type coverage. + +Examples: + # Scan all workflows + mxcli bson discover -p app.mpr --type workflow + + # Scan a specific workflow + mxcli bson discover -p app.mpr --type workflow --object "Module.WfName" +`, + Run: runDiscover, +} + +func init() { + discoverCmd.Flags().StringP("type", "t", "workflow", "Object type: workflow, microflow, page, nanoflow, enumeration") + discoverCmd.Flags().StringP("object", "o", "", "Specific object qualified name (e.g., Module.WfName)") +} + +func runDiscover(cmd *cobra.Command, args []string) { + projectPath, _ := cmd.Flags().GetString("project") + objectType, _ := cmd.Flags().GetString("type") + objectName, _ := cmd.Flags().GetString("object") + + if projectPath == "" { + fmt.Fprintln(os.Stderr, "Error: --project (-p) is required") + os.Exit(1) + } + + reader, err := mpr.Open(projectPath) + if err != nil { + fmt.Fprintf(os.Stderr, "Error opening project: %v\n", err) + os.Exit(1) + } + defer reader.Close() + + var rawUnits []bsondiscover.RawUnit + + if objectName != "" { + unit, err := reader.GetRawUnitByName(objectType, objectName) + if err != nil { + fmt.Fprintf(os.Stderr, "Error getting %s: %v\n", objectName, err) + os.Exit(1) + } + parsed, err := unmarshalBsonFields(unit.Contents) + if err != nil { + fmt.Fprintf(os.Stderr, "Error parsing BSON for %s: %v\n", objectName, err) + os.Exit(1) + } + rawUnits = collectNestedUnits(unit.QualifiedName, parsed) + } else { + units, err := reader.ListRawUnits(objectType) + if err != nil { + fmt.Fprintf(os.Stderr, "Error listing %s units: %v\n", objectType, err) + os.Exit(1) + } + for _, unit := range units { + parsed, err := unmarshalBsonFields(unit.Contents) + if err != nil { + fmt.Fprintf(os.Stderr, "Warning: failed to parse BSON for %s: %v\n", unit.QualifiedName, err) + continue + } + nested := collectNestedUnits(unit.QualifiedName, parsed) + rawUnits = append(rawUnits, nested...) + } + } + + if len(rawUnits) == 0 { + fmt.Fprintln(os.Stderr, "No objects found") + os.Exit(1) + } + + // Run discover with empty MDL text (pure field inventory mode). + dr := bsondiscover.RunDiscover(rawUnits, "") + fmt.Print(bsondiscover.FormatResult(dr)) +} + +// unmarshalBsonFields parses raw BSON bytes into a map. +func unmarshalBsonFields(contents []byte) (map[string]any, error) { + var fields map[string]any + if err := bson.Unmarshal(contents, &fields); err != nil { + return nil, err + } + return fields, nil +} + +// collectNestedUnits extracts the top-level unit and all nested typed objects +// (activities, outcomes, etc.) from a BSON document tree. +func collectNestedUnits(qualifiedName string, fields map[string]any) []bsondiscover.RawUnit { + bsonType, _ := fields["$Type"].(string) + if bsonType == "" { + bsonType = "Unknown" + } + + var units []bsondiscover.RawUnit + units = append(units, bsondiscover.RawUnit{ + QualifiedName: qualifiedName, + BsonType: bsonType, + Fields: fields, + }) + + // Recurse into nested objects and arrays to find typed sub-objects. + for _, v := range fields { + switch val := v.(type) { + case map[string]any: + if _, hasType := val["$Type"]; hasType { + nested := collectNestedUnits(qualifiedName, val) + units = append(units, nested...) + } + case []any: + for _, elem := range val { + if m, ok := elem.(map[string]any); ok { + if _, hasType := m["$Type"]; hasType { + nested := collectNestedUnits(qualifiedName, m) + units = append(units, nested...) + } + } + } + } + } + + return units +} diff --git a/cmd/mxcli/cmd_dump_bson.go b/cmd/mxcli/cmd_bson_dump.go similarity index 82% rename from cmd/mxcli/cmd_dump_bson.go rename to cmd/mxcli/cmd_bson_dump.go index a21dbb2..ea031cf 100644 --- a/cmd/mxcli/cmd_dump_bson.go +++ b/cmd/mxcli/cmd_bson_dump.go @@ -8,20 +8,20 @@ import ( "os" "strings" + bsondebug "github.com/mendixlabs/mxcli/bson" "github.com/mendixlabs/mxcli/sdk/mpr" "github.com/spf13/cobra" "go.mongodb.org/mongo-driver/bson" ) -var dumpBsonCmd = &cobra.Command{ - Use: "dump-bson", - Short: "Dump raw BSON data for debugging", - Long: `Dump raw BSON data from Mendix project objects for debugging serialization issues. +var bsonDumpCmd = &cobra.Command{ + Use: "dump", + Short: "Dump raw BSON data from Mendix project objects", + Long: `Dump raw BSON data from Mendix project objects as JSON or NDSL. -This tool helps debug BSON serialization issues by dumping the raw BSON -structure as JSON. You can compare SDK-generated objects with Studio Pro-generated -objects to identify field name mismatches, structural differences, or array -version marker issues. +Use this to inspect the internal BSON structure of pages, microflows, workflows, +and other model elements. You can compare two objects side-by-side to identify +field differences, structural mismatches, or array marker issues. Object Types: page Dump a page @@ -33,16 +33,16 @@ Object Types: Examples: # List all pages - mxcli dump-bson -p app.mpr --type page --list + mxcli bson dump -p app.mpr --type page --list # Dump a specific page - mxcli dump-bson -p app.mpr --type page --object "PgTest.MyPage" + mxcli bson dump -p app.mpr --type page --object "PgTest.MyPage" # Compare two objects (outputs both as JSON for diff) - mxcli dump-bson -p app.mpr --type page --compare "PgTest.Broken" "PgTest.Fixed" + mxcli bson dump -p app.mpr --type page --compare "PgTest.Broken" "PgTest.Fixed" # Save dump to file - mxcli dump-bson -p app.mpr --type page --object "PgTest.MyPage" > mypage.json + mxcli bson dump -p app.mpr --type page --object "PgTest.MyPage" > mypage.json `, Run: func(cmd *cobra.Command, args []string) { projectPath, _ := cmd.Flags().GetString("project") @@ -79,6 +79,8 @@ Examples: return } + format, _ := cmd.Flags().GetString("format") + // Compare two objects if len(compareFlag) == 2 { obj1, err := reader.GetRawUnitByName(objectType, compareFlag[0]) @@ -104,6 +106,13 @@ Examples: os.Exit(1) } + if format == "ndsl" { + fmt.Printf("=== LEFT: %s ===\n%s\n\n=== RIGHT: %s ===\n%s\n", + compareFlag[0], bsondebug.Render(raw1, 0), + compareFlag[1], bsondebug.Render(raw2, 0)) + return + } + // Print diff report fmt.Printf("=== BSON DIFF: %s vs %s ===\n\n", compareFlag[0], compareFlag[1]) diffs := compareBsonDocs(raw1, raw2, "") @@ -126,6 +135,16 @@ Examples: os.Exit(1) } + if format == "ndsl" { + var doc bson.D + if err := bson.Unmarshal(obj.Contents, &doc); err != nil { + fmt.Fprintf(os.Stderr, "Error parsing BSON: %v\n", err) + os.Exit(1) + } + fmt.Println(bsondebug.Render(doc, 0)) + return + } + // Parse BSON and output as JSON var raw any if err := bson.Unmarshal(obj.Contents, &raw); err != nil { @@ -316,3 +335,11 @@ func formatValue(val any) string { return s } } + +func init() { + bsonDumpCmd.Flags().StringP("type", "t", "page", "Object type: page, microflow, nanoflow, enumeration, snippet, layout") + bsonDumpCmd.Flags().StringP("object", "o", "", "Object qualified name to dump (e.g., Module.PageName)") + bsonDumpCmd.Flags().BoolP("list", "l", false, "List all objects of the specified type") + bsonDumpCmd.Flags().StringSliceP("compare", "c", nil, "Compare two objects: --compare Obj1,Obj2") + bsonDumpCmd.Flags().String("format", "json", "Output format: json, ndsl") +} diff --git a/cmd/mxcli/cmd_tui.go b/cmd/mxcli/cmd_tui.go new file mode 100644 index 0000000..737e002 --- /dev/null +++ b/cmd/mxcli/cmd_tui.go @@ -0,0 +1,67 @@ +// SPDX-License-Identifier: Apache-2.0 + +package main + +import ( + "fmt" + "os" + + tea "github.com/charmbracelet/bubbletea" + "github.com/mendixlabs/mxcli/tui" + "github.com/spf13/cobra" +) + +var tuiCmd = &cobra.Command{ + Use: "tui", + Short: "Interactive terminal UI for Mendix projects", + Long: `Launch a ranger-style three-column TUI for browsing and operating on a Mendix project. + +Navigation: + h/← move focus left l/→/Enter move focus right / open + j/↓ move down k/↑ move up + Tab cycle panel focus / search in current column + : open command bar q quit + +Commands (via : bar): + :check check MDL syntax + :run run current MDL file + :callers show callers of selected element + :callees show callees of selected element + :context show context of selected element + :impact show impact of selected element + :refs show references to selected element + :diagram open diagram in browser + :search full-text search + +Example: + mxcli tui -p app.mpr +`, + Run: func(cmd *cobra.Command, args []string) { + projectPath, _ := cmd.Flags().GetString("project") + mxcliPath, _ := os.Executable() + + if projectPath == "" { + picker := tui.NewPickerModel() + p := tea.NewProgram(picker, tea.WithAltScreen()) + result, err := p.Run() + if err != nil { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + os.Exit(1) + } + m := result.(tui.PickerModel) + if m.Chosen() == "" { + return + } + projectPath = m.Chosen() + } + + tui.SaveHistory(projectPath) + + m := tui.New(mxcliPath, projectPath) + p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion()) + if _, err := p.Run(); err != nil { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + os.Exit(1) + } + }, +} diff --git a/cmd/mxcli/docker/build.go b/cmd/mxcli/docker/build.go index 9c81736..c07924d 100644 --- a/cmd/mxcli/docker/build.go +++ b/cmd/mxcli/docker/build.go @@ -700,7 +700,7 @@ func ensureDemoUsers(projectPath string, w io.Writer) error { } } - if err := writer.AddDemoUser(ps.ID, "admin", "Admin123!", []string{roleName}); err != nil { + if err := writer.AddDemoUser(ps.ID, "admin", "Admin123!", "", []string{roleName}); err != nil { return fmt.Errorf("creating demo user: %w", err) } diff --git a/cmd/mxcli/help_topics/entity.txt b/cmd/mxcli/help_topics/entity.txt index 3fb9959..e798e5a 100644 --- a/cmd/mxcli/help_topics/entity.txt +++ b/cmd/mxcli/help_topics/entity.txt @@ -34,6 +34,11 @@ Attribute Constraints: UNIQUE - Value must be unique UNIQUE ERROR 'msg' - Unique with custom error message DEFAULT value - Default value (true, false, 0, 'text') + CALCULATED BY Module.Microflow - Calculated attribute (persistent entities only) + CALCULATED Module.Microflow - Same as above (BY is optional) + CALCULATED - Marks as calculated (bind microflow in Studio Pro) + + Note: CALCULATED attributes are only supported on persistent entities. Complete Example: CREATE PERSISTENT ENTITY MyModule.Customer ( @@ -48,7 +53,10 @@ Complete Example: CreatedAt: DateTime, -- Enumeration reference - CustomerType: Enumeration(MyModule.CustomerType) + CustomerType: Enumeration(MyModule.CustomerType), + + -- Calculated attribute (value computed by microflow) + FullName: String(200) CALCULATED BY MyModule.CalcFullName ) INDEX (Email) COMMENT 'Stores customer information'; diff --git a/cmd/mxcli/help_topics/security.txt b/cmd/mxcli/help_topics/security.txt index 57285c5..546ad55 100644 --- a/cmd/mxcli/help_topics/security.txt +++ b/cmd/mxcli/help_topics/security.txt @@ -43,7 +43,7 @@ PROJECT SECURITY: ALTER PROJECT SECURITY DEMO USERS ON|OFF; DEMO USERS: - CREATE DEMO USER '' PASSWORD '' ( [, ...]); + CREATE DEMO USER '' PASSWORD '' [ENTITY Module.Entity] ( [, ...]); DROP DEMO USER ''; Examples: diff --git a/cmd/mxcli/help_topics/workflow.txt b/cmd/mxcli/help_topics/workflow.txt index d0cb37e..53faf43 100644 --- a/cmd/mxcli/help_topics/workflow.txt +++ b/cmd/mxcli/help_topics/workflow.txt @@ -47,6 +47,55 @@ CROSS-REFERENCES - user_targeting: user task targeting microflow - admin_page: workflow overview page +CREATE WORKFLOW +-------------- + + CREATE [OR MODIFY] WORKFLOW Module.WorkflowName + PARAMETER $Context: Module.Entity + [OVERVIEW PAGE Module.OverviewPage] + [DUE DATE ''] + BEGIN + + END WORKFLOW; + + Activity types: + USER TASK '' + [PAGE Module.Page] + [TARGETING MICROFLOW Module.MF | TARGETING XPATH ''] + [ENTITY Module.Entity] + [OUTCOMES '' { } '' { }]; + + CALL MICROFLOW Module.MF [COMMENT ''] + [OUTCOMES '' { } ...]; + + CALL WORKFLOW Module.WF [COMMENT '']; + + DECISION [''] [COMMENT ''] + OUTCOMES '' { } ...; + + PARALLEL SPLIT [COMMENT ''] + PATH 1 { } + PATH 2 { }; + + JUMP TO [COMMENT '']; + WAIT FOR TIMER [''] [COMMENT '']; + WAIT FOR NOTIFICATION [COMMENT '']; + END; + + Example: + CREATE WORKFLOW Module.ApprovalFlow + PARAMETER $Context: Module.Request + BEGIN + USER TASK ReviewTask 'Review the request' + PAGE Module.ReviewPage + OUTCOMES 'Approve' { } 'Reject' { }; + END WORKFLOW; + +DROP WORKFLOW +------------- + + DROP WORKFLOW Module.WorkflowName; + CODE NAVIGATION --------------- diff --git a/cmd/mxcli/lsp_completions_gen.go b/cmd/mxcli/lsp_completions_gen.go index 910fd6c..a0243f8 100644 --- a/cmd/mxcli/lsp_completions_gen.go +++ b/cmd/mxcli/lsp_completions_gen.go @@ -325,6 +325,7 @@ var mdlGeneratedKeywords = []protocol.CompletionItem{ {Label: "EXPRESSION", Kind: protocol.CompletionItemKindKeyword, Detail: "Validation keyword"}, {Label: "XPATH", Kind: protocol.CompletionItemKindKeyword, Detail: "Validation keyword"}, {Label: "CONSTRAINT", Kind: protocol.CompletionItemKindKeyword, Detail: "Validation keyword"}, + {Label: "CALCULATED", Kind: protocol.CompletionItemKindKeyword, Detail: "Validation keyword"}, // REST keyword {Label: "REST", Kind: protocol.CompletionItemKindKeyword, Detail: "REST keyword"}, @@ -469,9 +470,29 @@ var mdlGeneratedKeywords = []protocol.CompletionItem{ {Label: "ACCESS", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, {Label: "LEVEL", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, {Label: "USER", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "TASK", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "DECISION", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "SPLIT", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "OUTCOMES", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "TARGETING", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "NOTIFICATION", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "TIMER", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "JUMP", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "DUE", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "OVERVIEW", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "DATE", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "PARALLEL", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "WAIT", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "ANNOTATION", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "BOUNDARY", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "INTERRUPTING", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "NON", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "MULTI", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "BY", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, {Label: "READ", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, {Label: "WRITE", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, {Label: "DESCRIPTION", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, + {Label: "DISPLAY", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, {Label: "OFF", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, {Label: "USERS", Kind: protocol.CompletionItemKindKeyword, Detail: "Keyword"}, diff --git a/cmd/mxcli/main.go b/cmd/mxcli/main.go index b0b58d7..b2332bc 100644 --- a/cmd/mxcli/main.go +++ b/cmd/mxcli/main.go @@ -7,6 +7,7 @@ import ( "errors" "fmt" "os" + "strings" "github.com/mendixlabs/mxcli/mdl/diaglog" "github.com/mendixlabs/mxcli/mdl/executor" @@ -53,6 +54,25 @@ func shouldSuppressWarning() bool { return false } +// discoverProjectPath looks for a single .mpr file in the current directory. +// Returns the filename if exactly one is found, otherwise returns "". +func discoverProjectPath() string { + entries, err := os.ReadDir(".") + if err != nil { + return "" + } + var mprFiles []string + for _, e := range entries { + if !e.IsDir() && strings.HasSuffix(e.Name(), ".mpr") { + mprFiles = append(mprFiles, e.Name()) + } + } + if len(mprFiles) == 1 { + return mprFiles[0] + } + return "" +} + var rootCmd = &cobra.Command{ Use: "mxcli", Short: "Mendix CLI - Work with Mendix projects using MDL syntax", @@ -78,6 +98,15 @@ Examples: mxcli -p app.mpr -c "SHOW ENTITIES" `, Version: version, + PersistentPreRun: func(cmd *cobra.Command, args []string) { + projectPath, _ := cmd.Flags().GetString("project") + if projectPath == "" { + if discovered := discoverProjectPath(); discovered != "" { + _ = cmd.Flags().Set("project", discovered) + fmt.Fprintf(os.Stderr, "Using project: %s\n", discovered) + } + } + }, Run: func(cmd *cobra.Command, args []string) { // Get flags commands, _ := cmd.Flags().GetString("command") @@ -203,12 +232,6 @@ func init() { diffLocalCmd.Flags().BoolP("color", "", false, "Use colored output") diffLocalCmd.Flags().IntP("width", "w", 120, "Terminal width for side-by-side format") - // Dump-bson command flags - dumpBsonCmd.Flags().StringP("type", "t", "page", "Object type: page, microflow, nanoflow, enumeration, snippet, layout") - dumpBsonCmd.Flags().StringP("object", "o", "", "Object qualified name to dump (e.g., Module.PageName)") - dumpBsonCmd.Flags().BoolP("list", "l", false, "List all objects of the specified type") - dumpBsonCmd.Flags().StringSliceP("compare", "c", nil, "Compare two objects: --compare Obj1,Obj2") - // Describe command flags describeCmd.Flags().StringP("format", "f", "mdl", "Output format: mdl, mermaid, elk") @@ -263,7 +286,6 @@ func init() { rootCmd.AddCommand(checkCmd) rootCmd.AddCommand(diffCmd) rootCmd.AddCommand(diffLocalCmd) - rootCmd.AddCommand(dumpBsonCmd) rootCmd.AddCommand(callersCmd) rootCmd.AddCommand(calleesCmd) rootCmd.AddCommand(refsCmd) @@ -280,4 +302,5 @@ func init() { rootCmd.AddCommand(testRunCmd) rootCmd.AddCommand(playwrightCmd) rootCmd.AddCommand(evalCmd) + rootCmd.AddCommand(tuiCmd) } diff --git a/cmd/mxcli/skills/generate-domain-model.md b/cmd/mxcli/skills/generate-domain-model.md index 7c1b799..3d5321b 100644 --- a/cmd/mxcli/skills/generate-domain-model.md +++ b/cmd/mxcli/skills/generate-domain-model.md @@ -326,6 +326,29 @@ COMMENT 'Additional documentation'; **Naming Convention**: `{FromEntity}_{ToEntity}` (e.g., `Order_Customer`, `Transaction_Account`) +#### Calculated Attributes + +Calculated attributes derive their value from a microflow at runtime. Use `CALCULATED BY Module.Microflow` to specify the calculation microflow. + +**IMPORTANT: CALCULATED attributes are only supported on PERSISTENT entities.** Using CALCULATED on non-persistent entities will produce a validation error. + +```sql +@Position(100, 100) +CREATE PERSISTENT ENTITY Module.OrderLine ( + /** Unit price */ + UnitPrice: Decimal NOT NULL, + /** Quantity ordered */ + Quantity: Integer NOT NULL, + /** Total price, calculated by microflow */ + TotalPrice: Decimal CALCULATED BY Module.CalcTotalPrice +); +``` + +**Syntax variants:** +- `CALCULATED BY Module.Microflow` — recommended, binds the calculation microflow directly +- `CALCULATED Module.Microflow` — also valid (`BY` keyword is optional) +- `CALCULATED` — bare form, marks as calculated but requires manual microflow binding in Studio Pro + ### Data Types | Type | Example | Description | diff --git a/cmd/mxcli/skills/write-oql-queries.md b/cmd/mxcli/skills/write-oql-queries.md index bcdc1e9..8c4541e 100644 --- a/cmd/mxcli/skills/write-oql-queries.md +++ b/cmd/mxcli/skills/write-oql-queries.md @@ -502,7 +502,13 @@ LEFT JOIN Shop.Product_Category/Shop.Category AS cat - Ensure ALL SELECT columns have explicit AS aliases - Aliases must match entity attribute names exactly -### Step 8: Final Check +### Step 8: Validate Before Executing +```bash +mxcli check view.mdl -p app.mpr --references +``` +This catches type mismatches (e.g., declaring `Long` for a `count()` column that returns `Integer`), missing module references, and OQL syntax errors — before they become MxBuild errors like CE6770 ("View Entity is out of sync with the OQL Query"). + +### Step 9: Final Check - Remove any ORDER BY, LIMIT, or OFFSET clauses - These should be handled by the UI component or microflow @@ -665,7 +671,8 @@ The app must be running first: `mxcli docker run -p app.mpr --wait` 1. **Write and test interactively**: `mxcli oql -p app.mpr "SELECT ..."` 2. **Iterate** until the query returns expected results 3. **Embed** in a VIEW ENTITY with matching column aliases and attribute types -4. **Apply and rebuild**: `mxcli exec view.mdl -p app.mpr && mxcli docker run -p app.mpr --fresh --wait` +4. **Validate before executing**: `mxcli check view.mdl -p app.mpr --references` to catch type mismatches (e.g., `Long` vs `Integer` for `count()`) +5. **Apply and rebuild**: `mxcli exec view.mdl -p app.mpr && mxcli docker run -p app.mpr --fresh --wait` ## Integration with MDL Linter @@ -714,5 +721,6 @@ When writing OQL queries for VIEW entities, always verify: - [ ] Association navigation uses correct syntax: `Entity_Assoc/Target AS alias` - [ ] JOIN ON clauses use comparison operators: `ON a.Field = b.Field` - [ ] Subqueries are enclosed in parentheses and return appropriate values +- [ ] **Validate before executing**: Run `mxcli check script.mdl -p app.mpr --references` to catch type mismatches Following these rules ensures your OQL queries will parse and execute correctly in Mendix runtime. diff --git a/docs/01-project/MDL_FEATURE_MATRIX.md b/docs/01-project/MDL_FEATURE_MATRIX.md index 024549f..3d05859 100644 --- a/docs/01-project/MDL_FEATURE_MATRIX.md +++ b/docs/01-project/MDL_FEATURE_MATRIX.md @@ -204,7 +204,7 @@ Document types that exist in Mendix but have no MDL support: | **JSON transformations** | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | JSON structure definitions | | **Message definitions** | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Message definition documents | | **XML schemas** | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Imported XML schema documents | -| **Workflows** | Y | Y | N | N | N | N | N | N | Y | Y | N | N | Y | N | N | Y | N | SHOW/DESCRIBE work; CREATE/DROP not implemented | +| **Workflows** | Y | Y | Y | N | Y | N | N | N | Y | Y | N | N | Y | N | Y | Y | N | SHOW/DESCRIBE/CREATE/DROP/GRANT/REVOKE implemented | | **Module settings** | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Module-level configuration | | **Image collection** | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Image document collections | | **Icon collection** | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Icon/glyph collections | diff --git a/docs/01-project/MDL_QUICK_REFERENCE.md b/docs/01-project/MDL_QUICK_REFERENCE.md index 11c9aac..a4a2227 100644 --- a/docs/01-project/MDL_QUICK_REFERENCE.md +++ b/docs/01-project/MDL_QUICK_REFERENCE.md @@ -208,9 +208,43 @@ Nested folders use `/` separator: `'Parent/Child/Grandchild'`. Missing folders a | Revoke entity access | `REVOKE Mod.Role ON Mod.Entity;` | | | Set security level | `ALTER PROJECT SECURITY LEVEL OFF\|PROTOTYPE\|PRODUCTION;` | | | Toggle demo users | `ALTER PROJECT SECURITY DEMO USERS ON\|OFF;` | | -| Create demo user | `CREATE DEMO USER 'name' PASSWORD 'pass' (UserRole, ...);` | | +| Create demo user | `CREATE DEMO USER 'name' PASSWORD 'pass' [ENTITY Module.Entity] (UserRole, ...);` | | | Drop demo user | `DROP DEMO USER 'name';` | | +## Workflows + +| Statement | Syntax | Notes | +|-----------|--------|-------| +| Show workflows | `SHOW WORKFLOWS [IN Module];` | List all or filter by module | +| Describe workflow | `DESCRIBE WORKFLOW Module.Name;` | Full MDL output | +| Create workflow | `CREATE [OR MODIFY] WORKFLOW Module.Name PARAMETER $Ctx: Module.Entity BEGIN ... END WORKFLOW;` | See activity types below | +| Drop workflow | `DROP WORKFLOW Module.Name;` | | +| Grant workflow access | `GRANT EXECUTE ON WORKFLOW Module.Name TO Mod.Role, ...;` | | +| Revoke workflow access | `REVOKE EXECUTE ON WORKFLOW Module.Name FROM Mod.Role, ...;` | | + +**Workflow Activity Types:** +- `USER TASK '' [PAGE Mod.Page] [TARGETING MICROFLOW Mod.MF] [OUTCOMES '' { } ...];` +- `CALL MICROFLOW Mod.MF [COMMENT ''] [OUTCOMES '' { } ...];` +- `CALL WORKFLOW Mod.WF [COMMENT ''];` +- `DECISION [''] OUTCOMES '' { } ...;` +- `PARALLEL SPLIT PATH 1 { } PATH 2 { };` +- `JUMP TO ;` +- `WAIT FOR TIMER [''];` +- `WAIT FOR NOTIFICATION;` +- `END;` + +**Example:** +```sql +CREATE WORKFLOW Module.ApprovalFlow + PARAMETER $Context: Module.Request + OVERVIEW PAGE Module.WorkflowOverview +BEGIN + USER TASK ReviewTask 'Review the request' + PAGE Module.ReviewPage + OUTCOMES 'Approve' { } 'Reject' { }; +END WORKFLOW; +``` + ## Project Structure | Statement | Syntax | Notes | @@ -417,6 +451,8 @@ Both double-quote (ANSI SQL) and backtick (MySQL) styles are supported. You can **Boolean attributes** auto-default to `false` when no `DEFAULT` is specified. +**CALCULATED** marks an attribute as calculated (not stored). Use `CALCULATED BY Module.Microflow` to specify the calculation microflow. Calculated attributes derive their value from a microflow at runtime. + **ButtonStyle** supports all values: `Primary`, `Default`, `Success`, `Danger`, `Warning`, `Info`. ## External SQL Statements diff --git a/docs/05-mdl-specification/01-language-reference.md b/docs/05-mdl-specification/01-language-reference.md index bfafbdd..6c750ee 100644 --- a/docs/05-mdl-specification/01-language-reference.md +++ b/docs/05-mdl-specification/01-language-reference.md @@ -405,7 +405,7 @@ CREATE [OR MODIFY] ENTITY ( **Attribute Definition:** ```sql [/** */] -: [NOT NULL [ERROR '']] [UNIQUE [ERROR '']] [DEFAULT ] +: [NOT NULL [ERROR '']] [UNIQUE [ERROR '']] [DEFAULT ] [CALCULATED] ``` **Examples:** @@ -1084,12 +1084,15 @@ Creates a demo user for development/testing. **Syntax:** ```sql -CREATE DEMO USER '' PASSWORD '' ( [, ...]) +CREATE DEMO USER '' PASSWORD '' [ENTITY ] ( [, ...]) ``` +The optional `ENTITY` clause specifies the entity that generalizes `System.User` (e.g., `Administration.Account`). If omitted, the system auto-detects the unique `System.User` subtype. + **Example:** ```sql CREATE DEMO USER 'demo_admin' PASSWORD 'Admin123!' (AppAdmin); +CREATE DEMO USER 'demo_admin' PASSWORD 'Admin123!' ENTITY Administration.Account (AppAdmin); ``` ### DROP DEMO USER diff --git a/docs/plans/2026-03-22-bson-discover-tool-design.md b/docs/plans/2026-03-22-bson-discover-tool-design.md new file mode 100644 index 0000000..fb1de4f --- /dev/null +++ b/docs/plans/2026-03-22-bson-discover-tool-design.md @@ -0,0 +1,385 @@ +# BSON Discover Tool Design + +## Problem + +MDL's DESCRIBE output is a lossy projection of BSON data. When implementing new features (workflows, pages, microflows), there's no systematic way to: + +1. **Discover** which BSON fields are missing from DESCRIBE/CREATE coverage +2. **Compare** reference BSON (Studio Pro) vs generated BSON (mxcli) field-by-field +3. **Validate** round-trip fidelity: CREATE → mx check → DESCRIBE → compare original BSON + +Today this requires ad-hoc Go scripts, manual JSON diffing, and Python one-liners. The workflow baseline comparison (2026-03-22) revealed that `DESCRIBE WORKFLOW` drops ~50% of semantic fields (UserTargeting, DueDate, CompletionCriteria, TaskName, TaskDescription, OnCreatedEvent, etc.). + +## Solution + +A unified `mxcli bson` subcommand suite for BSON discovery, comparison, and round-trip validation. Debug-only — not included in release builds. + +## Commands + +### `mxcli bson discover` + +Analyzes field coverage: what BSON fields exist vs what MDL DESCRIBE outputs. + +```bash +# Scan all workflows, report field coverage per $Type +mxcli bson discover -p app.mpr --type workflow + +# Scan a specific object +mxcli bson discover -p app.mpr --type workflow --object "Module.WfName" + +# Other types +mxcli bson discover -p app.mpr --type microflow +mxcli bson discover -p app.mpr --type page +``` + +**Output:** + +``` +Workflows$Workflow (2 objects scanned) + ✓ Name covered + ✓ Parameter covered (PARAMETER) + ✓ Flow covered (BEGIN...END) + ✗ Title UNCOVERED (string, ex: "Workflow") + ✗ AdminPage UNCOVERED (null) + ✗ DueDate UNCOVERED (string, ex: "") + ✗ WorkflowName UNCOVERED (*MicroflowsStringTemplate) + ✗ WorkflowDescription UNCOVERED (*MicroflowsStringTemplate) + ✗ OnWorkflowEvent UNCOVERED (slice, empty) + ✗ WorkflowV2 UNCOVERED (bool, ex: false) + - $ID, PersistentId, Size... structural (5 fields) + + Coverage: 8/15 semantic fields (53%) + +Workflows$SingleUserTaskActivity (5 instances) + ✓ Name, Caption, TaskPage covered + ✓ Outcomes covered (OUTCOMES) + ✗ UserTargeting UNCOVERED (*WorkflowsUserTargeting) + ✗ AutoAssignSingleTargetUser UNCOVERED (bool, ex: false) + ✗ DueDate UNCOVERED (string, ex: "") + ✗ TaskName UNCOVERED (*MicroflowsStringTemplate) + ✗ TaskDescription UNCOVERED (*MicroflowsStringTemplate) + ✗ OnCreatedEvent UNCOVERED (*WorkflowsUserTaskEvent) + ✗ BoundaryEvents UNCOVERED (slice, empty) + + Coverage: 4/13 semantic fields (31%) +``` + +**Algorithm:** + +1. Read all BSON objects of the given type from MPR +2. For each unique `$Type` encountered, collect all field names and sample values +3. Look up the `$Type` in the reflect-based TypeRegistry → get full field list from generated metamodel structs +4. Run DESCRIBE on the object → capture MDL text output +5. For each semantic field, use heuristic matching to check if its value appears in MDL output: + - String values: substring search in MDL text + - Bool/int values: search stringified form + - Object/null: mark as `unknown` (needs manual confirmation, or defaults to uncovered if null/default value) +6. Fields in BSON but not in reflect metadata → flagged as `unknown-to-schema` (version mismatch) +7. Report coverage per `$Type` + +### `mxcli bson compare` + +Diff two BSON objects, skipping structural/layout noise. + +```bash +# Same MPR, two objects +mxcli bson compare -p app.mpr --type workflow "Module.WfA" "Module.WfB" + +# Cross-MPR comparison (reference vs generated) +mxcli bson compare --type workflow -p ref.mpr "Module.Wf" -p2 test.mpr "Module.Wf" + +# Show all differences including structural +mxcli bson compare --type workflow -p ref.mpr "Module.Wf" -p2 test.mpr "Module.Wf" --all +``` + +**Output:** + +``` +Workflows$Workflow + = Name: "Workflow" + ≠ Title: "Workflow" vs "" ← value mismatch + ≠ WorkflowV2: false vs (missing) ← field absent + +Workflows$SingleUserTaskActivity [userTask1] + = Name, Caption, TaskPage + + AutoAssignSingleTargetUser: false ← only in left + + UserTargeting: XPathUserTargeting{...} ← only in left + + OnCreatedEvent: NoEvent ← only in left + +Summary: 12 differences, 8 only-in-left, 0 only-in-right, 4 value-mismatches +``` + +**Design:** + +- Extends existing `dump-bson --compare` logic (currently in `cmd_dump_bson.go`) +- Recursive diff on BSON `map[string]any` trees +- Default skip set: `$ID`, `PersistentId`, `RelativeMiddlePoint`, `Size` (overridable with `--all`) +- Activity matching: by `Name` field within the same `$Type` (not by array index) +- Array diffing: match elements by `$Type` + identifying field (`Name`, `Value`, `Caption`) + +### `mxcli bson roundtrip` + +Automated CREATE → mx check → DESCRIBE → compare cycle. + +```bash +# Full round-trip validation +mxcli bson roundtrip -p app.mpr --type workflow --object "Module.WfName" + +# All objects of a type +mxcli bson roundtrip -p app.mpr --type workflow --all + +# Skip mx check (fast mode) +mxcli bson roundtrip -p app.mpr --type workflow --object "Module.WfName" --skip-check +``` + +**Output:** + +``` +Step 1: DESCRIBE → MDL .......................... OK (45 lines) +Step 2: Copy project ............................ OK (/tmp/mxcli-rt-xxxxx/) +Step 3: DROP + CREATE ........................... OK +Step 4: mx check ................................ OK (0 errors) +Step 5: BSON compare (ref vs generated) ......... 8 differences + + UserTargeting (5 instances) lost in round-trip + + AutoAssignSingleTargetUser (5 instances) lost in round-trip + + OnCreatedEvent (5 instances) lost in round-trip + = Flow structure identical + = Parameter mappings identical +Step 6: MDL compare (DESCRIBE before vs after) .. 0 differences + +Result: BSON round-trip has 8 field losses, MDL round-trip is lossless +``` + +**Workflow:** + +1. Read original BSON from source MPR (reference) +2. DESCRIBE → capture MDL text +3. Copy project to temp directory +4. Execute DROP + CREATE with generated MDL +5. Run `mx check` on temp project (skip if `--skip-check` or mxbuild not installed) +6. Read new BSON from temp project +7. Run Compare (reference vs new) → report field-level differences +8. DESCRIBE again on temp project → compare MDL text (MDL round-trip check) +9. Clean up temp directory (unless `--keep-temp`) + +### `mxcli bson dump` + +Existing functionality from `dump-bson`, relocated under the `bson` parent command. + +```bash +mxcli bson dump -p app.mpr --type workflow --list +mxcli bson dump -p app.mpr --type workflow --object "Module.WfName" +``` + +## Architecture + +### Build Tag Isolation + +All BSON tool code compiles only with `//go:build debug`: + +``` +cmd/mxcli/ + cmd_bson.go //go:build debug — register "bson" parent command + cmd_dump_bson.go //go:build debug — existing dump-bson, moved under "bson dump" + +bson/ //go:build debug — core logic package + registry.go — reflect-based TypeRegistry + discover.go — field coverage analysis + compare.go — recursive BSON diff + roundtrip.go — full round-trip validation + classify.go — field category rules +``` + +**Build commands:** + +```makefile +# Release (default) — no bson commands, no size impact +make build + +# Debug — includes bson discover/compare/roundtrip/dump +make build-debug +# go build -tags debug -o bin/mxcli-debug ./cmd/mxcli +``` + +### TypeRegistry (registry.go) + +Runtime reflect scanning of `generated/metamodel` structs. No external JSON files needed. + +```go +//go:build debug + +package bson + +import ( + "reflect" + "strings" + "github.com/mendixlabs/mxcli/generated/metamodel" +) + +// TypeRegistry maps BSON $Type → Go reflect.Type +// Populated at init time. +var TypeRegistry = map[string]reflect.Type{ + "Workflows$Workflow": reflect.TypeOf(metamodel.WorkflowsWorkflow{}), + "Workflows$SingleUserTaskActivity": reflect.TypeOf(metamodel.WorkflowsSingleUserTaskActivity{}), + "Workflows$MultiUserTaskActivity": reflect.TypeOf(metamodel.WorkflowsMultiUserTaskActivity{}), + "Workflows$CallMicroflowTask": reflect.TypeOf(metamodel.WorkflowsCallMicroflowTask{}), + "Workflows$CallWorkflowActivity": reflect.TypeOf(metamodel.WorkflowsCallWorkflowActivity{}), + "Workflows$ExclusiveSplitActivity": reflect.TypeOf(metamodel.WorkflowsExclusiveSplitActivity{}), + "Workflows$ParallelSplitActivity": reflect.TypeOf(metamodel.WorkflowsParallelSplitActivity{}), + "Workflows$JumpToActivity": reflect.TypeOf(metamodel.WorkflowsJumpToActivity{}), + "Workflows$WaitForTimerActivity": reflect.TypeOf(metamodel.WorkflowsWaitForTimerActivity{}), + "Workflows$WaitForNotificationActivity": reflect.TypeOf(metamodel.WorkflowsWaitForNotificationActivity{}), + // ... extensible to other namespaces (Microflows$, Forms$, DomainModels$) +} + +// PropertyMeta describes a single field's metadata derived from reflect. +type PropertyMeta struct { + GoFieldName string // "UserTargeting" + StorageName string // "userTargeting" (from json tag, maps to BSON field name) + GoType string // "*WorkflowsUserTargeting" + IsList bool // reflect.Kind == Slice + IsPointer bool // reflect.Kind == Ptr + IsRequired bool // json tag lacks "omitempty" + Category FieldCategory // structural / layout / semantic +} + +type FieldCategory int + +const ( + Semantic FieldCategory = iota // Business fields (Name, Entity, Expression) + Structural // Internal ($ID, $Type, PersistentId) + Layout // Visual only (RelativeMiddlePoint, Size) +) + +// GetFieldMeta returns all field metadata for a $Type. +// Returns nil if the type is not in the registry. +func GetFieldMeta(bsonType string) []PropertyMeta { + rt, ok := TypeRegistry[bsonType] + if !ok { + return nil + } + + var result []PropertyMeta + for i := 0; i < rt.NumField(); i++ { + f := rt.Field(i) + if f.Anonymous { continue } // skip BaseElement + + jsonTag := f.Tag.Get("json") + storageName, _ := parseJSONTag(jsonTag) + isRequired := !strings.Contains(jsonTag, "omitempty") + + result = append(result, PropertyMeta{ + GoFieldName: f.Name, + StorageName: storageName, + GoType: f.Type.String(), + IsList: f.Type.Kind() == reflect.Slice, + IsPointer: f.Type.Kind() == reflect.Ptr, + IsRequired: isRequired, + Category: classifyField(storageName), + }) + } + return result +} +``` + +### Field Classification (classify.go) + +Minimal hardcoded rules. Everything else defaults to Semantic. + +```go +var structuralFields = map[string]bool{ + "$ID": true, "$Type": true, "PersistentId": true, +} + +var layoutFields = map[string]bool{ + "RelativeMiddlePoint": true, "Size": true, +} + +func classifyField(storageName string) FieldCategory { + if structuralFields[storageName] { return Structural } + if layoutFields[storageName] { return Layout } + return Semantic +} +``` + +### MDL Coverage Heuristic (discover.go) + +No hardcoded field-to-MDL mapping table. Instead, value-based matching: + +```go +func checkFieldCoverage(storageName string, bsonValue any, mdlText string) CoverageStatus { + switch v := bsonValue.(type) { + case string: + if v == "" { return DefaultValue } + if strings.Contains(mdlText, v) { return Covered } + return Uncovered + + case bool: + // booleans are tricky — "false" might not appear in MDL + if !v { return DefaultValue } + if strings.Contains(mdlText, "true") { return Covered } + return Uncovered + + case nil: + return DefaultValue // null PartProperty + + case map[string]any: + // Nested object — check if any leaf value appears in MDL + return checkNestedCoverage(v, mdlText) + + default: + return Unknown + } +} +``` + +Coverage statuses: +- `Covered` — field value found in MDL output +- `Uncovered` — field has non-default value but not in MDL +- `DefaultValue` — field is empty/null/false (may be intentionally omitted from MDL) +- `Unknown` — cannot determine automatically + +### Supported Types + +The `--type` flag maps to BSON unit types and `ListRawUnits()`: + +| --type | BSON prefix | TypeRegistry entries needed | +|--------|-------------|---------------------------| +| workflow | Workflows$Workflow | Workflows$* (all activity types) | +| microflow | Microflows$Microflow | Microflows$* (60+ action types) | +| page | Forms$Page | Forms$* (50+ widget types) | +| entity | DomainModels$Entity | DomainModels$* | +| enumeration | Enumerations$Enumeration | Enumerations$* | + +TypeRegistry is extensible — add entries as needed. Types not in the registry still work for compare/dump (raw BSON diff), but discover reports them as `unknown-to-schema`. + +## Scope & Priorities + +### Phase 1 (Initial) + +- `bson dump` — migrate existing `dump-bson` under new parent command +- `bson discover` — field coverage for workflow types +- `bson compare` — single-MPR and cross-MPR diff +- Build tag isolation (`//go:build debug`) +- `make build-debug` target + +### Phase 2 + +- `bson roundtrip` — full automated round-trip validation +- Extend TypeRegistry to microflow types + +### Phase 3 + +- Extend TypeRegistry to page and domain model types +- `--format json` output for CI integration + +## Non-Goals + +- No changes to release binary +- No changes to generated `types.go` (no `mx` struct tags) +- No embedded reflection JSON files +- No automated fix suggestions (just discovery and reporting) + +## Cleanup + +- Remove `/mnt/data_sdd/gh/mxcli/cmd/dump-wf/` (temporary dump script created during this design session) diff --git a/docs/plans/2026-03-22-tui-enhancement-design.md b/docs/plans/2026-03-22-tui-enhancement-design.md new file mode 100644 index 0000000..8e675bf --- /dev/null +++ b/docs/plans/2026-03-22-tui-enhancement-design.md @@ -0,0 +1,219 @@ +# TUI Enhancement Design + +**Date**: 2026-03-22 +**Status**: Draft + +## Context + +The current TUI (`mxcli tui`) uses bubbles `list.Model` for panels with page-based scrolling, fixed 3-panel layout, no mouse support, no syntax highlighting, and no BSON/NDSL integration. This design overhauls the TUI for a more fluid, interactive experience. + +## Requirements + +1. **Unified ScrollList** — Replace `list.Model` with custom component using picker-style smooth scrolling + visual scrollbar +2. **Breadcrumb navigation** — Top of each panel shows navigation path, clickable +3. **Z mode** — Press `z` to zoom current panel to fullscreen +4. **Progressive expansion** — Start with 1 panel, expand as user drills in +5. **Panel 3 summary mode** — Show metadata summary, Enter opens fullscreen overlay +6. **Mouse support** — Click selection, scroll wheel, breadcrumb click +7. **MDL/SQL/NDSL syntax highlighting** — Using alecthomas/chroma +8. **BSON/NDSL commands** — Cmdbar verbs with multi-level completion + +## Architecture + +### New Files + +| File | Lines | Responsibility | +|------|-------|----------------| +| `tui/panels/scrolllist.go` | ~350 | Reusable scrollable list: cursor, scrollOffset, scrollbar, filter, mouse | +| `tui/panels/breadcrumb.go` | ~80 | Breadcrumb path display and click-to-navigate | +| `tui/highlight.go` | ~120 | Chroma-based syntax highlighting (MDL/SQL/NDSL) | +| `tui/overlay.go` | ~150 | Fullscreen overlay with scrollable viewport | + +### Modified Files + +| File | Changes | +|------|---------| +| `tui/panels/modules.go` | Replace `list.Model` → `ScrollList`, add breadcrumb + nav stack | +| `tui/panels/elements.go` | Same refactor as modules | +| `tui/layout.go` | Dynamic panel widths, `PanelRect` geometry for mouse hit testing | +| `tui/model.go` | Visibility state, zen mode, mouse routing, overlay integration, BSON dispatch | +| `tui/styles.go` | Remove duplicate `typeIconMap`, add scrollbar/overlay styles | +| `tui/cmdbar.go` | Multi-level completion tree, qualified name completion | + +### New Dependency + +- `github.com/alecthomas/chroma/v2` + +## Phase 1: ScrollList + Breadcrumb (Foundation) + +### ScrollList (`tui/panels/scrolllist.go`) + +```go +type ScrollListItem interface { + Label() string + Icon() string + Description() string + FilterValue() string +} + +type ScrollList struct { + items []ScrollListItem + filteredItems []int // indices into items (nil = no filter) + cursor int + scrollOffset int + filterInput textinput.Model + filterActive bool + width, height int + focused bool + headerHeight int // reserved for breadcrumb +} +``` + +**Scrolling**: `scrollOffset + maxVisible` window. Cursor moves smoothly, scrollOffset follows. + +**Scrollbar**: Right-side vertical track (`│`) with thumb (`█`). Position = `scrollOffset / (total - maxVisible) * trackHeight`. + +**Mouse**: `MouseWheelUp/Down` adjusts scrollOffset. `MouseActionPress` computes `clickedIndex = scrollOffset + (Y - topOffset)`. + +**Filter**: `/` activates textinput, real-time substring filter on `FilterValue()`. Esc exits. + +### Breadcrumb (`tui/panels/breadcrumb.go`) + +```go +type BreadcrumbSegment struct { + Label string +} + +type Breadcrumb struct { + segments []BreadcrumbSegment + width int +} +``` + +Methods: `Push()`, `PopTo(level)`, `Depth()`, `View()` (renders `A > B > C`), `ClickedSegment(x int) int`. + +### Panel Refactor + +Each panel (modules, elements) maintains: +- `ScrollList` instead of `list.Model` +- `Breadcrumb` for navigation path +- `navigationStack [][]*TreeNode` for drill-in/back + +## Phase 2: Progressive Expansion + Z Mode + +### Dynamic Layout (`tui/layout.go`) + +```go +type PanelVisibility int +const ( + ShowOnePanel PanelVisibility = iota // modules only, 100% + ShowTwoPanels // modules 35% + elements 65% + ShowThreePanels // 20% + 30% + 50% + ShowZoomed // zoomed panel 100% +) + +type PanelRect struct { + X, Y, Width, Height int + Visible bool +} +``` + +### Visibility State Machine + +- Start: `ShowOnePanel` +- Select module + right/enter → `ShowTwoPanels` +- Select element → `ShowThreePanels` +- Left from elements (empty stack) → `ShowOnePanel` +- Left from preview → `ShowTwoPanels` + +### Z Mode + +- `z` toggles between `ShowZoomed` and previous visibility +- Remembers `zenPrevFocus` and `zenPrevVisibility` for restore +- `Esc` also exits zen mode + +## Phase 3: Mouse Support + +Root model translates `tea.MouseMsg` coordinates using `PanelRect`: + +```go +case tea.MouseMsg: + for i, rect := range m.panelLayout { + if rect.contains(msg.X, msg.Y) { + localMsg := translateMouse(msg, rect) + m.focus = Focus(i) + // forward to panel + } + } +``` + +ScrollList handles translated coordinates internally. Breadcrumb click detected by checking `localMsg.Y < headerHeight`. + +## Phase 4: Summary + Overlay + Highlighting + +### Preview Summary Mode + +Panel 3 shows compact metadata card: +``` +Type: Entity +Module: MyModule +Name: Customer +Attrs: 5 Assocs: 2 +[Enter] view details +``` + +`SetContent()` stores both `summaryContent` (panel) and `fullContent` (overlay). + +### Fullscreen Overlay (`tui/overlay.go`) + +- Reuses `viewport.Model` for scrollable content +- `lipgloss.Place` for centering +- Title bar + content + bottom hints +- Serves: detail view, BSON dump, NDSL output + +### Syntax Highlighting (`tui/highlight.go`) + +- `alecthomas/chroma/v2` with `terminal256` formatter + `monokai` style +- SQL lexer as MDL base +- Custom NDSL lexer (regex: field paths, type annotations, values) +- Functions: `HighlightMDL()`, `HighlightSQL()`, `HighlightNDSL()`, `DetectAndHighlight()` + +## Phase 5: BSON/NDSL Commands + +### Multi-level Cmdbar + +```go +type cmdDef struct { + name string + children []cmdDef +} +``` + +Commands: `bson dump `, `bson compare `, `ndsl ` + +Completion levels: +1. Command name (bson, ndsl, callers, ...) +2. Subcommand (dump, compare) +3. Qualified name (from flattened tree nodes) + +Results → `HighlightNDSL()` → `OpenOverlayMsg` → fullscreen overlay + +## Phase Dependency + +``` +Phase 1 (ScrollList + Breadcrumb) + ├──→ Phase 2 (Layout + Z Mode) + │ └──→ Phase 3 (Mouse) + └──→ Phase 4 (Summary + Overlay + Highlighting) + └──→ Phase 5 (BSON/NDSL Commands) +``` + +Phases 2 and 4 can proceed in parallel after Phase 1. + +## Verification + +After each phase: +1. `make build` — compiles cleanly +2. `./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr` — manual testing +3. Verify scrolling, mouse, breadcrumb, overlay, highlighting visually +4. Run `make test` for any unit tests added diff --git a/docs/plans/2026-03-22-tui.md b/docs/plans/2026-03-22-tui.md new file mode 100644 index 0000000..c09a8c2 --- /dev/null +++ b/docs/plans/2026-03-22-tui.md @@ -0,0 +1,1256 @@ +# TUI (mxcli tui) Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Add `mxcli tui` — a ranger-style three-column terminal UI that replicates the VS Code MDL extension's project navigation and command features. + +**Architecture:** Three Bubble Tea panels (modules list, elements list, preview viewport) share a root Model. Navigation uses h/j/k/l vim keys. Commands are dispatched by a bottom command bar (`:` prefix). All heavy lifting delegates to existing `mxcli` logic — the tree is built by calling `buildProjectTree()` directly; describe/callers/exec/check run `mxcli` as a subprocess. Diagrams open in the system browser via `xdg-open`/`open`. + +**Tech Stack:** Go, [Bubble Tea](https://github.com/charmbracelet/bubbletea) (TUI), [Lip Gloss](https://github.com/charmbracelet/lipgloss) (styling), [Bubbles](https://github.com/charmbracelet/bubbles) (list + viewport + textinput components) + +--- + +## Task 1: Add Bubble Tea dependencies + +**Files:** +- Modify: `go.mod` / `go.sum` (via `go get`) + +**Step 1: Add dependencies** + +```bash +cd /mnt/data_sdd/gh/mxcli +go get github.com/charmbracelet/bubbletea@latest +go get github.com/charmbracelet/lipgloss@latest +go get github.com/charmbracelet/bubbles@latest +``` + +**Step 2: Verify they appear in go.mod** + +```bash +grep "charmbracelet" go.mod +``` +Expected: three lines for bubbletea, lipgloss, bubbles. + +**Step 3: Build to confirm no breakage** + +```bash +make build +``` +Expected: `bin/mxcli` produced, no errors. + +**Step 4: Commit** + +```bash +git add go.mod go.sum +git commit -m "chore: add bubbletea/lipgloss/bubbles dependencies for TUI" +``` + +--- + +## Task 2: TUI package skeleton + styles + +**Files:** +- Create: `tui/styles.go` +- Create: `tui/model.go` (root Model, empty Update/View) +- Create: `tui/runner.go` (subprocess helpers) + +### `tui/styles.go` + +```go +package tui + +import "github.com/charmbracelet/lipgloss" + +var ( + colFocusedBorder = lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("63")) + + colNormalBorder = lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("240")) + + statusBarStyle = lipgloss.NewStyle(). + Background(lipgloss.Color("236")). + Foreground(lipgloss.Color("252")). + Padding(0, 1) + + cmdBarStyle = lipgloss.NewStyle(). + Foreground(lipgloss.Color("214")). + Bold(true) + + titleStyle = lipgloss.NewStyle(). + Bold(true). + Foreground(lipgloss.Color("39")) + + dimStyle = lipgloss.NewStyle(). + Foreground(lipgloss.Color("240")) + + typeIconMap = map[string]string{ + "module": "⬡", + "domainmodel": "⊞", + "entity": "▣", + "externalentity": "⊡", + "association": "↔", + "enumeration": "≡", + "microflow": "⚙", + "nanoflow": "⚡", + "workflow": "⬡", + "page": "▤", + "snippet": "⬔", + "layout": "⬕", + "constant": "π", + "javaaction": "☕", + "javascriptaction": "JS", + "scheduledevent": "⏰", + "folder": "📁", + "security": "🔒", + "modulerole": "👤", + "userrole": "👥", + "projectsecurity": "🛡", + "navigation": "🧭", + "systemoverview": "🗺", + "businesseventservice": "📡", + "databaseconnection": "🗄", + "odataservice": "🌐", + "odataclient": "🔗", + "publishedrestservice": "REST", + "workflow": "🔀", + } +) + +func iconFor(nodeType string) string { + if icon, ok := typeIconMap[nodeType]; ok { + return icon + } + return "·" +} +``` + +### `tui/runner.go` + +```go +package tui + +import ( + "bytes" + "os/exec" + "strings" +) + +// runMxcli runs a mxcli subcommand and returns stdout. +// mxcliPath is the path to the mxcli binary (os.Args[0] works for self). +func runMxcli(mxcliPath string, args ...string) (string, error) { + var buf bytes.Buffer + var errBuf bytes.Buffer + cmd := exec.Command(mxcliPath, args...) + cmd.Stdout = &buf + cmd.Stderr = &errBuf + if err := cmd.Run(); err != nil { + combined := strings.TrimSpace(buf.String() + "\n" + errBuf.String()) + return combined, err + } + return buf.String(), nil +} + +// openBrowser opens a URL or file path in the system browser. +func openBrowser(target string) error { + // Try xdg-open (Linux), open (macOS), start (Windows) + for _, bin := range []string{"xdg-open", "open", "start"} { + if path, err := exec.LookPath(bin); err == nil { + return exec.Command(path, target).Start() + } + } + return nil // silently ignore if no browser found +} +``` + +### `tui/model.go` + +```go +package tui + +import ( + "github.com/charmbracelet/bubbletea" +) + +// Focus indicates which panel has keyboard focus. +type Focus int + +const ( + FocusModules Focus = iota + FocusElements + FocusPreview +) + +// Model is the root Bubble Tea model for the TUI. +type Model struct { + mxcliPath string + projectPath string + width int + height int + focus Focus + // panels populated in Task 3 +} + +func New(mxcliPath, projectPath string) Model { + return Model{ + mxcliPath: mxcliPath, + projectPath: projectPath, + focus: FocusModules, + } +} + +func (m Model) Init() tea.Cmd { return nil } + +func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + switch msg := msg.(type) { + case tea.KeyMsg: + if msg.String() == "ctrl+c" || msg.String() == "q" { + return m, tea.Quit + } + case tea.WindowSizeMsg: + m.width = msg.Width + m.height = msg.Height + } + return m, nil +} + +func (m Model) View() string { + return "mxcli tui — loading...\n\nPress q to quit" +} +``` + +**Step 1: Create the three files above.** + +**Step 2: Build to confirm package compiles** + +```bash +cd /mnt/data_sdd/gh/mxcli && go build ./tui/... +``` +Expected: no errors. + +**Step 3: Commit** + +```bash +git add tui/ +git commit -m "feat(tui): add package skeleton, styles, runner helpers" +``` + +--- + +## Task 3: cobra command `mxcli tui` + +**Files:** +- Create: `cmd/mxcli/cmd_tui.go` +- Modify: `cmd/mxcli/main.go` (register command) + +### `cmd/mxcli/cmd_tui.go` + +```go +// SPDX-License-Identifier: Apache-2.0 + +package main + +import ( + "fmt" + "os" + + tea "github.com/charmbracelet/bubbletea" + "github.com/mendixlabs/mxcli/tui" + "github.com/spf13/cobra" +) + +var tuiCmd = &cobra.Command{ + Use: "tui", + Short: "Interactive terminal UI for Mendix projects", + Long: `Launch a ranger-style three-column TUI for browsing and operating on a Mendix project. + +Navigation: + h/← move focus left l/→/Enter move focus right / open + j/↓ move down k/↑ move up + Tab cycle panel focus / search in current column + : open command bar q quit + +Commands (via : bar): + :check check MDL syntax + :run run current MDL file + :callers show callers of selected element + :callees show callees of selected element + :context show context of selected element + :impact show impact of selected element + :refs show references to selected element + :diagram open diagram in browser + :search full-text search + +Example: + mxcli tui -p app.mpr +`, + Run: func(cmd *cobra.Command, args []string) { + projectPath, _ := cmd.Flags().GetString("project") + if projectPath == "" { + fmt.Fprintln(os.Stderr, "Error: --project (-p) is required") + os.Exit(1) + } + + mxcliPath, _ := os.Executable() + m := tui.New(mxcliPath, projectPath) + p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion()) + if _, err := p.Run(); err != nil { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + os.Exit(1) + } + }, +} + +func init() { + // project flag already registered on rootCmd; tui inherits it +} +``` + +**In `main.go`**, find the block that adds commands (around line 290-310) and add: + +```go +rootCmd.AddCommand(tuiCmd) +``` + +**Step 1: Create `cmd_tui.go` as above.** + +**Step 2: Register in `main.go`.** + +**Step 3: Build and smoke-test** + +```bash +make build +./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +Expected: screen clears, shows "mxcli tui — loading...", press q exits cleanly. + +**Step 4: Commit** + +```bash +git add cmd/mxcli/cmd_tui.go cmd/mxcli/main.go +git commit -m "feat(tui): add mxcli tui cobra command" +``` + +--- + +## Task 4: Modules panel (left column) + +**Files:** +- Create: `tui/panels/modules.go` +- Modify: `tui/model.go` (integrate panel) + +The modules panel is a scrollable list of `TreeNode` roots loaded from `buildProjectTree`. +Because `buildProjectTree` is in package `main`, we call `mxcli project-tree` as a subprocess and parse the JSON. + +### `tui/panels/modules.go` + +```go +package panels + +import ( + "encoding/json" + + "github.com/charmbracelet/bubbles/list" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// TreeNode mirrors cmd/mxcli.TreeNode for JSON parsing. +type TreeNode struct { + Label string `json:"label"` + Type string `json:"type"` + QualifiedName string `json:"qualifiedName,omitempty"` + Children []*TreeNode `json:"children,omitempty"` +} + +// nodeItem wraps TreeNode for the bubbles list. +type nodeItem struct{ node *TreeNode } + +func (n nodeItem) Title() string { return n.node.Label } +func (n nodeItem) Description() string { return n.node.Type } +func (n nodeItem) FilterValue() string { return n.node.Label } + +// ModulesPanel is the left column: a list of top-level tree nodes (modules + special nodes). +type ModulesPanel struct { + list list.Model + nodes []*TreeNode + focused bool + width int + height int +} + +func NewModulesPanel(width, height int) ModulesPanel { + delegate := list.NewDefaultDelegate() + delegate.ShowDescription = false + l := list.New(nil, delegate, width, height) + l.SetShowTitle(true) + l.Title = "Modules" + l.SetShowStatusBar(false) + l.SetFilteringEnabled(true) + return ModulesPanel{list: l, width: width, height: height} +} + +// LoadTreeMsg carries parsed tree nodes from project-tree output. +type LoadTreeMsg struct { + Nodes []*TreeNode + Err error +} + +// ParseTree parses JSON from mxcli project-tree output. +func ParseTree(jsonStr string) ([]*TreeNode, error) { + var nodes []*TreeNode + if err := json.Unmarshal([]byte(jsonStr), &nodes); err != nil { + return nil, err + } + return nodes, nil +} + +func (p *ModulesPanel) SetNodes(nodes []*TreeNode) { + p.nodes = nodes + items := make([]list.Item, len(nodes)) + for i, n := range nodes { + items[i] = nodeItem{node: n} + } + p.list.SetItems(items) +} + +func (p ModulesPanel) SelectedNode() *TreeNode { + item, ok := p.list.SelectedItem().(nodeItem) + if !ok { + return nil + } + return item.node +} + +func (p *ModulesPanel) SetSize(w, h int) { + p.width = w + p.height = h + p.list.SetWidth(w) + p.list.SetHeight(h) +} + +func (p *ModulesPanel) SetFocused(f bool) { p.focused = f } + +func (p ModulesPanel) Update(msg tea.Msg) (ModulesPanel, tea.Cmd) { + var cmd tea.Cmd + p.list, cmd = p.list.Update(msg) + return p, cmd +} + +func (p ModulesPanel) View() string { + border := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(borderColor(p.focused)) + return border.Render(p.list.View()) +} + +func borderColor(focused bool) lipgloss.Color { + if focused { + return lipgloss.Color("63") + } + return lipgloss.Color("240") +} +``` + +**Update `tui/model.go`** to: +1. Import `panels` package +2. Add `modulesPanel panels.ModulesPanel` field +3. In `Init()`, return a command that calls `mxcli project-tree -p ` and sends `LoadTreeMsg` +4. In `Update()`, handle `LoadTreeMsg` to populate `modulesPanel` +5. In `View()`, show the modules panel in the left column + +The Init command: +```go +func (m Model) Init() tea.Cmd { + return func() tea.Msg { + out, err := runMxcli(m.mxcliPath, "project-tree", "-p", m.projectPath) + if err != nil { + return panels.LoadTreeMsg{Err: err} + } + nodes, err := panels.ParseTree(out) + return panels.LoadTreeMsg{Nodes: nodes, Err: err} + } +} +``` + +**Step 1: Create `tui/panels/modules.go`.** + +**Step 2: Update `tui/model.go`** to wire modules panel (Init, Update, View). + +**Step 3: Build and test** + +```bash +make build +./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +Expected: left column shows list of modules (System Overview, Navigation, modules...), j/k scrolls. + +**Step 4: Commit** + +```bash +git add tui/panels/modules.go tui/model.go +git commit -m "feat(tui): modules panel — left column with project tree" +``` + +--- + +## Task 5: Elements panel (middle column) + +**Files:** +- Create: `tui/panels/elements.go` +- Modify: `tui/model.go` (integrate, wire selection) + +The elements panel shows children of the currently selected module node. +When the user presses `l` or `Enter` on a module, its `Children` populate this panel. +Elements that themselves have children (e.g. Domain Model category) show a `▶` suffix. + +### `tui/panels/elements.go` + +```go +package panels + +import ( + "github.com/charmbracelet/bubbles/list" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// ElementsPanel is the middle column: children of the selected module node. +type ElementsPanel struct { + list list.Model + nodes []*TreeNode + focused bool + width int + height int +} + +func NewElementsPanel(width, height int) ElementsPanel { + delegate := list.NewDefaultDelegate() + delegate.ShowDescription = true + l := list.New(nil, delegate, width, height) + l.Title = "Elements" + l.SetShowStatusBar(false) + l.SetFilteringEnabled(true) + return ElementsPanel{list: l, width: width, height: height} +} + +func (p *ElementsPanel) SetNodes(nodes []*TreeNode) { + p.nodes = nodes + items := make([]list.Item, len(nodes)) + for i, n := range nodes { + label := n.Label + if len(n.Children) > 0 { + label += " ▶" + } + items[i] = nodeItem{node: &TreeNode{ + Label: label, + Type: n.Type, + QualifiedName: n.QualifiedName, + Children: n.Children, + }} + } + p.list.SetItems(items) + p.list.ResetSelected() +} + +func (p ElementsPanel) SelectedNode() *TreeNode { + item, ok := p.list.SelectedItem().(nodeItem) + if !ok { + return nil + } + return item.node +} + +func (p *ElementsPanel) SetSize(w, h int) { + p.width = w + p.height = h + p.list.SetWidth(w) + p.list.SetHeight(h) +} + +func (p *ElementsPanel) SetFocused(f bool) { p.focused = f } + +func (p ElementsPanel) Update(msg tea.Msg) (ElementsPanel, tea.Cmd) { + var cmd tea.Cmd + p.list, cmd = p.list.Update(msg) + return p, cmd +} + +func (p ElementsPanel) View() string { + border := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(borderColor(p.focused)) + return border.Render(p.list.View()) +} +``` + +**Wire in `tui/model.go`:** +- Add `elementsPanel panels.ElementsPanel` field +- When `FocusModules` and user presses `l`/`Enter`: set elements panel nodes from `modulesPanel.SelectedNode().Children`, switch focus to `FocusElements` +- When `FocusElements` and user presses `h`: switch focus back to `FocusModules` +- When `FocusElements` and user presses `l`/`Enter` on a node WITH children: push those children into elements panel (drill down) + +**Step 1: Create `tui/panels/elements.go`.** + +**Step 2: Update `tui/model.go`** with focus switching logic and elements panel wiring. + +**Step 3: Test** + +```bash +make build && ./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +Expected: select a module → press `l` → middle column shows its children. Press `h` → back to modules. + +**Step 4: Commit** + +```bash +git add tui/panels/elements.go tui/model.go +git commit -m "feat(tui): elements panel — middle column with drill-down navigation" +``` + +--- + +## Task 6: Preview panel (right column) + +**Files:** +- Create: `tui/panels/preview.go` +- Modify: `tui/model.go` (wire describe call + focus) + +The preview panel is a scrollable viewport showing DESCRIBE output. +When the user selects a leaf node in the elements panel, the TUI calls `mxcli describe -p ` and pipes the result here. + +### `tui/panels/preview.go` + +```go +package panels + +import ( + "github.com/charmbracelet/bubbles/viewport" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// PreviewPanel is the right column: DESCRIBE output in a scrollable viewport. +type PreviewPanel struct { + viewport viewport.Model + focused bool + loading bool + width int + height int +} + +// DescribeResultMsg carries DESCRIBE output. +type DescribeResultMsg struct { + Content string + Err error +} + +func NewPreviewPanel(width, height int) PreviewPanel { + vp := viewport.New(width, height) + vp.SetContent("Select an element to preview its DESCRIBE output.") + return PreviewPanel{viewport: vp, width: width, height: height} +} + +func (p *PreviewPanel) SetContent(content string) { + p.loading = false + p.viewport.SetContent(content) + p.viewport.GotoTop() +} + +func (p *PreviewPanel) SetLoading() { + p.loading = true + p.viewport.SetContent("Loading...") +} + +func (p *PreviewPanel) SetSize(w, h int) { + p.width = w + p.height = h + p.viewport.Width = w + p.viewport.Height = h +} + +func (p *PreviewPanel) SetFocused(f bool) { p.focused = f } + +func (p PreviewPanel) Update(msg tea.Msg) (PreviewPanel, tea.Cmd) { + var cmd tea.Cmd + p.viewport, cmd = p.viewport.Update(msg) + return p, cmd +} + +func (p PreviewPanel) View() string { + title := "Preview" + if p.loading { + title = "Preview (loading...)" + } + header := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("39")).Render(title) + border := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(borderColor(p.focused)) + return border.Render(header + "\n" + p.viewport.View()) +} +``` + +**Wire in `tui/model.go`:** + +When `FocusElements` and user presses `l`/`Enter` on a leaf (no children): +1. Switch focus to `FocusPreview` +2. Call `previewPanel.SetLoading()` +3. Return tea.Cmd that runs `mxcli describe -p ` and sends `DescribeResultMsg` + +Handle `DescribeResultMsg` in Update: +```go +case panels.DescribeResultMsg: + if msg.Err != nil { + m.previewPanel.SetContent("-- Error: " + msg.Err.Error()) + } else { + m.previewPanel.SetContent(msg.Content) + } +``` + +Also trigger describe automatically when selection changes in elements panel (without switching focus). + +**Step 1: Create `tui/panels/preview.go`.** + +**Step 2: Update `tui/model.go`** to wire describe calls and preview panel. + +**Step 3: Test** + +```bash +make build && ./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +Expected: navigate to a microflow → right column shows its DESCRIBE output (parameters, activities). Press `j`/`k` in preview to scroll. + +**Step 4: Commit** + +```bash +git add tui/panels/preview.go tui/model.go +git commit -m "feat(tui): preview panel — DESCRIBE output viewport" +``` + +--- + +## Task 7: Layout engine (three-column view) + +**Files:** +- Create: `tui/layout.go` +- Modify: `tui/model.go` (use layout in View) + +The layout splits terminal width 20% / 30% / 50% across the three columns, with a status bar at the bottom. + +### `tui/layout.go` + +```go +package tui + +import ( + "fmt" + "github.com/charmbracelet/lipgloss" +) + +// columnWidths returns [modulesW, elementsW, previewW] given total terminal width. +func columnWidths(totalW int) (int, int, int) { + // Reserve 2 chars per border (left+right) × 3 columns = 6 + available := totalW - 6 + if available < 30 { + available = 30 + } + modulesW := available * 20 / 100 + elementsW := available * 30 / 100 + previewW := available - modulesW - elementsW + return modulesW, elementsW, previewW +} + +// renderLayout assembles the three panels + status bar into the full screen. +func renderLayout( + totalW, totalH int, + modulesView, elementsView, previewView string, + statusLine string, +) string { + // Status bar at bottom (1 line) + status := lipgloss.NewStyle(). + Background(lipgloss.Color("236")). + Foreground(lipgloss.Color("252")). + Width(totalW). + Render(statusLine) + + // Content rows = height - 1 (status bar) + cols := lipgloss.JoinHorizontal(lipgloss.Top, modulesView, elementsView, previewView) + + return fmt.Sprintf("%s\n%s", cols, status) +} +``` + +**Update `tui/model.go` View():** + +```go +func (m Model) View() string { + mW, eW, pW := columnWidths(m.width) + contentH := m.height - 2 // status bar + command bar + m.modulesPanel.SetSize(mW, contentH) + m.elementsPanel.SetSize(eW, contentH) + m.previewPanel.SetSize(pW, contentH) + + status := fmt.Sprintf(" mxcli tui %s [Tab: cycle focus | :: command | q: quit]", + m.projectPath) + + return renderLayout( + m.width, m.height, + m.modulesPanel.View(), + m.elementsPanel.View(), + m.previewPanel.View(), + status, + ) +} +``` + +**Step 1: Create `tui/layout.go`.** + +**Step 2: Update `tui/model.go` View()** as above. + +**Step 3: Test at various terminal sizes** + +```bash +make build && ./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +Resize terminal — columns should reflow. No text overflow. + +**Step 4: Commit** + +```bash +git add tui/layout.go tui/model.go +git commit -m "feat(tui): responsive three-column layout with status bar" +``` + +--- + +## Task 8: Command bar (`:` trigger) + +**Files:** +- Create: `tui/cmdbar.go` +- Modify: `tui/model.go` (integrate cmdbar, dispatch commands) + +### `tui/cmdbar.go` + +```go +package tui + +import ( + "strings" + + "github.com/charmbracelet/bubbles/textinput" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// CmdBar is the bottom command input bar activated by ":". +type CmdBar struct { + input textinput.Model + visible bool +} + +func NewCmdBar() CmdBar { + ti := textinput.New() + ti.Placeholder = "command (run, check, callers, callees, context, impact, refs, diagram, search )" + ti.Prompt = ": " + ti.CharLimit = 200 + return CmdBar{input: ti} +} + +func (c *CmdBar) Show() { + c.visible = true + c.input.SetValue("") + c.input.Focus() +} + +func (c *CmdBar) Hide() { + c.visible = false + c.input.Blur() +} + +func (c CmdBar) IsVisible() bool { return c.visible } + +// Command returns the current input value split into verb + args. +func (c CmdBar) Command() (verb string, rest string) { + parts := strings.SplitN(strings.TrimSpace(c.input.Value()), " ", 2) + if len(parts) == 0 { + return "", "" + } + verb = strings.ToLower(parts[0]) + if len(parts) > 1 { + rest = parts[1] + } + return verb, rest +} + +func (c CmdBar) Update(msg tea.Msg) (CmdBar, tea.Cmd) { + var cmd tea.Cmd + c.input, cmd = c.input.Update(msg) + return c, cmd +} + +func (c CmdBar) View() string { + if !c.visible { + return lipgloss.NewStyle(). + Foreground(lipgloss.Color("240")). + Render(" :run :check :callers :callees :context :impact :refs :diagram :search") + } + return lipgloss.NewStyle(). + Bold(true).Foreground(lipgloss.Color("214")). + Render(c.input.View()) +} +``` + +**Update `tui/model.go`:** + +1. Add `cmdbar CmdBar` field, init with `NewCmdBar()` +2. In `Update`, when not in cmdbar mode: `:` key → `m.cmdbar.Show()` +3. When cmdbar visible: route all keys to cmdbar; `Esc` → hide; `Enter` → dispatch command +4. Command dispatch (in a `dispatchCommand` method): + +```go +func (m *Model) dispatchCommand(verb, rest string) tea.Cmd { + node := m.elementsPanel.SelectedNode() + if node == nil { + node = m.modulesPanel.SelectedNode() + } + qn := "" + nodeType := "" + if node != nil { + qn = node.QualifiedName + nodeType = node.Type + } + + switch verb { + case "check": + // TODO Task 9 + case "run": + // TODO Task 9 + case "callers": + return m.runShowCmd(fmt.Sprintf("SHOW CALLERS OF %s.%s", nodeType, qn)) + case "callees": + return m.runShowCmd(fmt.Sprintf("SHOW CALLEES OF %s.%s", nodeType, qn)) + case "context": + return m.runShowCmd(fmt.Sprintf("SHOW CONTEXT OF %s.%s", nodeType, qn)) + case "impact": + return m.runShowCmd(fmt.Sprintf("SHOW IMPACT OF %s.%s", nodeType, qn)) + case "refs": + return m.runShowCmd(fmt.Sprintf("SHOW REFERENCES OF %s.%s", nodeType, qn)) + case "diagram": + return m.openDiagram(nodeType, qn) + case "search": + return m.runShowCmd(fmt.Sprintf("SEARCH '%s'", rest)) + } + return nil +} +``` + +**Step 1: Create `tui/cmdbar.go`.** + +**Step 2: Integrate into `tui/model.go`** (add field, wire `:` key, dispatch). + +**Step 3: Test** + +```bash +make build && ./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +Press `:` → command bar appears at bottom. Type `callers` → Enter → preview shows SHOW CALLERS output. Press `Esc` to dismiss. + +**Step 4: Commit** + +```bash +git add tui/cmdbar.go tui/model.go +git commit -m "feat(tui): command bar — : trigger, run/check/callers/refs/diagram dispatch" +``` + +--- + +## Task 9: Command implementations (run, check, show commands, diagram) + +**Files:** +- Modify: `tui/model.go` (implement helper methods) + +### Helper methods to add to `model.go` + +```go +// CmdResultMsg carries output from any mxcli command. +type CmdResultMsg struct { + Output string + Err error +} + +// runShowCmd executes an MDL statement via `mxcli -p -c ""` +// and sends result to preview panel. +func (m Model) runShowCmd(stmt string) tea.Cmd { + return func() tea.Msg { + out, err := runMxcli(m.mxcliPath, "-p", m.projectPath, "-c", stmt) + return CmdResultMsg{Output: out, Err: err} + } +} + +// runCheck runs `mxcli check` on a script file. +// Since TUI has no editor, we check the last-run file. +func (m Model) runCheck(filePath string) tea.Cmd { + return func() tea.Msg { + out, err := runMxcli(m.mxcliPath, "check", filePath, "-p", m.projectPath) + return CmdResultMsg{Output: out, Err: err} + } +} + +// openDiagram generates a temp HTML file via `mxcli describe --format elk` +// and opens it in the system browser. +func (m Model) openDiagram(nodeType, qualifiedName string) tea.Cmd { + return func() tea.Msg { + // Use mxcli describe --format elk to get JSON, wrap in HTML + out, err := runMxcli(m.mxcliPath, "describe", "-p", m.projectPath, + "--format", "elk", nodeType, qualifiedName) + if err != nil { + return CmdResultMsg{Output: out, Err: err} + } + + // Write temp HTML file + htmlContent := buildDiagramHTML(out, nodeType, qualifiedName) + tmpFile, err := os.CreateTemp("", "mxcli-diagram-*.html") + if err != nil { + return CmdResultMsg{Err: err} + } + defer tmpFile.Close() + tmpFile.WriteString(htmlContent) + + // Open in browser + openBrowser(tmpFile.Name()) + return CmdResultMsg{Output: fmt.Sprintf("Opened diagram in browser: %s", tmpFile.Name())} + } +} + +// buildDiagramHTML wraps ELK JSON in a minimal HTML page using the same +// ELK.js rendering as the VS Code extension. +func buildDiagramHTML(elkJSON, nodeType, qualifiedName string) string { + return fmt.Sprintf(` + + + %s %s + + + + +
+ + +`, nodeType, qualifiedName, elkJSON) +} +``` + +**Note:** `buildDiagramHTML` can start minimal. The VS Code extension's `elkTemplate.ts` contains the full renderer — we can optionally embed it as a Go string constant in a future iteration. For now a placeholder that shows the JSON is acceptable. + +**Handle `CmdResultMsg` in Update:** + +```go +case CmdResultMsg: + if msg.Err != nil { + m.previewPanel.SetContent("-- Error:\n" + msg.Output) + } else { + m.previewPanel.SetContent(msg.Output) + } + m.focus = FocusPreview +``` + +**Step 1: Add all helper methods to `tui/model.go`.** + +**Step 2: Test each command** + +```bash +make build && ./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +- Navigate to a microflow → `:callers` → preview shows callers +- Navigate to a module → `:diagram` → browser opens with diagram HTML +- `:search hello` → preview shows search results + +**Step 3: Commit** + +```bash +git add tui/model.go tui/runner.go +git commit -m "feat(tui): implement run/check/show/diagram command dispatch" +``` + +--- + +## Task 10: Auto-preview on selection change + keyboard shortcuts + +**Files:** +- Modify: `tui/model.go` + +**Features:** +1. When moving `j`/`k` in elements panel → auto-trigger describe in background (debounced via 150ms timer) +2. `d` shortcut → open diagram (same as `:diagram`) +3. `r` shortcut → refresh project tree (re-run Init) +4. `/` in modules/elements panels → activate list filter mode (bubbles handles this natively) +5. `Tab` → cycle focus: modules → elements → preview → modules +6. `Esc` in preview → move focus back to elements + +**Auto-preview on j/k:** + +```go +// In Update, when FocusElements and msg is KeyMsg j/k: +// Forward to elementsPanel.Update, then fire describe for new selection. +case tea.KeyMsg: + if m.focus == FocusElements && !m.cmdbar.IsVisible() { + switch msg.String() { + case "j", "down", "k", "up": + m.elementsPanel, _ = m.elementsPanel.Update(msg) + // trigger auto-preview + if node := m.elementsPanel.SelectedNode(); node != nil && node.QualifiedName != "" { + m.previewPanel.SetLoading() + return m, m.describeNode(node) + } + } + } +``` + +**Step 1: Add auto-preview, Tab cycling, `d`/`r` shortcuts.** + +**Step 2: Test** + +```bash +make build && ./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` +- Move down elements list → preview updates automatically +- Press `d` → diagram opens in browser +- Press `r` → tree refreshes +- Press `Tab` → focus cycles through panels + +**Step 3: Commit** + +```bash +git add tui/model.go +git commit -m "feat(tui): auto-preview on selection, keyboard shortcuts d/r/Tab" +``` + +--- + +## Task 11: Help overlay + error handling + +**Files:** +- Create: `tui/help.go` +- Modify: `tui/model.go` + +### `tui/help.go` + +```go +package tui + +import "github.com/charmbracelet/lipgloss" + +const helpText = ` + mxcli tui — Keyboard Reference + + NAVIGATION + h / ← move focus left + l / → / Enter open / move focus right + j / ↓ move down + k / ↑ move up + Tab cycle panel focus + / search/filter in current column + Esc back / close + + COMMANDS (press : to activate) + :run run MDL file + :check check MDL syntax + :callers show callers of selected element + :callees show callees + :context show context + :impact show impact + :refs show references + :diagram open diagram in browser + :search full-text search + + OTHER + d open diagram in browser + r refresh project tree + ? show/hide this help + q quit +` + +func renderHelp(width, height int) string { + return lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("63")). + Width(width/2). + Padding(1, 2). + Render(helpText) +} +``` + +Add `showHelp bool` to Model; `?` key toggles it; help renders as an overlay in `View()`. + +**Step 1: Create `tui/help.go` and wire `?` key.** + +**Step 2: Commit** + +```bash +git add tui/help.go tui/model.go +git commit -m "feat(tui): help overlay (?), error display in preview" +``` + +--- + +## Task 12: Smoke test + final polish + +**Step 1: End-to-end smoke test** + +```bash +make build +./bin/mxcli tui -p /mnt/data_sdd/gh/mxproj-GenAIDemo/App.mpr +``` + +Walk through: +- [ ] Left column shows modules list +- [ ] `l` on a module → middle column shows children +- [ ] `l` on a leaf → right column shows DESCRIBE output +- [ ] `j`/`k` in elements → preview auto-updates +- [ ] `:callers` → shows callers in preview +- [ ] `:diagram` → browser opens +- [ ] `r` → tree refreshes +- [ ] `?` → help overlay +- [ ] `q` → exits cleanly +- [ ] Resize terminal → layout reflows + +**Step 2: Run `make build` for final build check** + +```bash +make build +``` + +**Step 3: Final commit** + +```bash +git add -A +git commit -m "feat(tui): mxcli tui — ranger-style TUI for Mendix project navigation" +``` + +--- + +## Feature Parity Summary + +| vscode-mdl Feature | TUI Equivalent | Status | +|---|---|---| +| Project Tree View | Three-column ranger navigation | Task 3–5 | +| DESCRIBE virtual docs | Preview panel viewport | Task 6 | +| MDL: Check File | `:check` command | Task 8–9 | +| MDL: Run File | `:run` command | Task 8–9 | +| Show Callers/Callees/Context/Impact/Refs | `:callers` etc. | Task 8–9 | +| Diagram Preview | `:diagram` → browser HTML | Task 9 | +| Full-text Search | `:search ` | Task 8–9 | +| Terminal link navigation | Auto-preview on selection | Task 10 | +| LSP (completion, diagnostics) | Not implemented (use Vim/Emacs LSP) | — | diff --git a/docs/plans/2026-03-22-workflow-metadata-gaps.md b/docs/plans/2026-03-22-workflow-metadata-gaps.md new file mode 100644 index 0000000..e7a10f7 --- /dev/null +++ b/docs/plans/2026-03-22-workflow-metadata-gaps.md @@ -0,0 +1,106 @@ +# Workflow Metadata Gaps: DISPLAY NAME, DESCRIPTION, EXPORT LEVEL + +## Problem + +DESCRIBE WORKFLOW outputs WorkflowName, WorkflowDescription, and ExportLevel as comments (`-- Display Name: X`), which CREATE cannot parse back. This breaks round-trip fidelity. The `bson discover` tool confirms 0% semantic field coverage for Workflows$Workflow. + +## Solution + +Add three optional MDL clauses to CREATE/ALTER WORKFLOW: `DISPLAY NAME`, `DESCRIPTION`, `EXPORT LEVEL`. + +## Syntax + +```sql +CREATE WORKFLOW Module.MyWorkflow + PARAMETER $WorkflowContext: Module.Entity + DISPLAY NAME 'My Workflow' + DESCRIPTION 'Handles the approval process' + EXPORT LEVEL Hidden + DUE DATE 'addDays([%CurrentDateTime%], 7)' + OVERVIEW PAGE Module.OverviewPage + +BEGIN + ... +END WORKFLOW +``` + +All three clauses are optional. Position: workflow header section (between PARAMETER and BEGIN), alongside existing DUE DATE and OVERVIEW PAGE. + +### EXPORT LEVEL values + +From `WorkflowsExportLevel` enum: `Hidden` (default), `Usable`. + +## Changes Required + +### 1. Grammar (MDLParser.g4) + +Add three new rules in the `workflowHeader` section: + +```antlr +workflowDisplayName: DISPLAY NAME stringLiteral; +workflowDescription: DESCRIPTION stringLiteral; +workflowExportLevel: EXPORT LEVEL (HIDDEN | USABLE); +``` + +New tokens needed: `DISPLAY`, `DESCRIPTION` (may already exist), `HIDDEN`, `USABLE`. + +Add these as optional children of the `createWorkflowStatement` rule, after `workflowParameter` and before `BEGIN`. + +### 2. AST (ast/ast_workflow.go) + +Add fields to `CreateWorkflowStatement`: + +```go +DisplayName string // from DISPLAY NAME 'text' +Description string // from DESCRIPTION 'text' +ExportLevel string // "Hidden" or "Usable", default "" +``` + +### 3. Visitor (visitor/visitor_workflow.go) + +Handle the new grammar rules in `ExitCreateWorkflowStatement` or dedicated listener methods. Extract string values and populate AST fields. + +### 4. Executor CREATE path (executor/cmd_workflows_write.go) + +Pass DisplayName, Description, ExportLevel from AST to the workflow SDK struct: + +```go +wf.WorkflowName = stmt.DisplayName +wf.WorkflowDescription = stmt.Description +if stmt.ExportLevel != "" { + wf.ExportLevel = stmt.ExportLevel +} +``` + +### 5. DESCRIBE output (executor/cmd_workflows.go) + +Change from comment format to MDL clauses: + +```go +// Before: +// lines = append(lines, fmt.Sprintf("-- Display Name: %s", targetWf.WorkflowName)) + +// After: +if targetWf.WorkflowName != "" { + lines = append(lines, fmt.Sprintf(" DISPLAY NAME '%s'", escape(targetWf.WorkflowName))) +} +``` + +### 6. BSON writer (sdk/mpr/writer_workflow.go) + +Already handles WorkflowName, WorkflowDescription, ExportLevel in BSON serialization. The SDK workflow struct already has these fields. No writer changes needed — just need to populate the struct correctly from the executor. + +## Scope + +### In scope +- DISPLAY NAME, DESCRIPTION, EXPORT LEVEL in CREATE WORKFLOW +- Updated DESCRIBE output (clauses instead of comments) +- Grammar, AST, visitor, executor changes +- Round-trip test: DESCRIBE → CREATE → mx check → DESCRIBE (should match) + +### Out of scope +- Annotation (UI sticky note, low round-trip value) +- AdminPage (rarely used) +- Excluded flag (rarely used) +- ALTER WORKFLOW support (future) +- UserTask-level TaskName/TaskDescription gaps (separate effort) diff --git a/go.mod b/go.mod index 48072ad..1b810b5 100644 --- a/go.mod +++ b/go.mod @@ -4,6 +4,9 @@ go 1.26.0 require ( github.com/antlr4-go/antlr/v4 v4.13.1 + github.com/charmbracelet/bubbles v1.0.0 + github.com/charmbracelet/bubbletea v1.3.10 + github.com/charmbracelet/lipgloss v1.1.0 github.com/chzyer/readline v1.5.1 github.com/jackc/pgx/v5 v5.8.0 github.com/microsoft/go-mssqldb v1.9.8 @@ -21,7 +24,19 @@ require ( ) require ( + github.com/alecthomas/chroma/v2 v2.23.1 // indirect + github.com/atotto/clipboard v0.1.4 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/charmbracelet/colorprofile v0.4.1 // indirect + github.com/charmbracelet/x/ansi v0.11.6 // indirect + github.com/charmbracelet/x/cellbuf v0.0.15 // indirect + github.com/charmbracelet/x/term v0.2.2 // indirect + github.com/clipperhouse/displaywidth v0.9.0 // indirect + github.com/clipperhouse/stringish v0.1.1 // indirect + github.com/clipperhouse/uax29/v2 v2.5.0 // indirect + github.com/dlclark/regexp2 v1.11.5 // indirect github.com/dustin/go-humanize v1.0.1 // indirect + github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect github.com/golang-sql/sqlexp v0.1.0 // indirect github.com/google/uuid v1.6.0 // indirect @@ -30,14 +45,23 @@ require ( github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/puddle/v2 v2.2.2 // indirect github.com/kr/text v0.2.0 // indirect + github.com/lucasb-eyer/go-colorful v1.3.0 // indirect github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.19 // indirect + github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect + github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/termenv v0.16.0 // indirect github.com/ncruces/go-strftime v0.1.9 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect + github.com/rivo/uniseg v0.4.7 // indirect github.com/rogpeppe/go-internal v1.6.1 // indirect + github.com/sahilm/fuzzy v0.1.1 // indirect github.com/segmentio/asm v1.1.3 // indirect github.com/segmentio/encoding v0.3.4 // indirect github.com/shopspring/decimal v1.4.0 // indirect github.com/spf13/pflag v1.0.5 // indirect + github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect go.lsp.dev/pkg v0.0.0-20210717090340-384b27a52fb2 // indirect go.uber.org/atomic v1.9.0 // indirect go.uber.org/multierr v1.8.0 // indirect diff --git a/go.sum b/go.sum index b462a4a..57f2be8 100644 --- a/go.sum +++ b/go.sum @@ -10,23 +10,57 @@ github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0 h1:nCYfg github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0/go.mod h1:ucUjca2JtSZboY8IoUqyQyuuXvwbMBVwFOm0vdQPNhA= github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 h1:XRzhVemXdgvJqCH0sFfrBUTnUJSBrBf7++ypk+twtRs= github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk= +github.com/alecthomas/chroma/v2 v2.23.1 h1:nv2AVZdTyClGbVQkIzlDm/rnhk1E9bU9nXwmZ/Vk/iY= +github.com/alecthomas/chroma/v2 v2.23.1/go.mod h1:NqVhfBR0lte5Ouh3DcthuUCTUpDC9cxBOfyMbMQPs3o= github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ= github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= +github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3vj1nolY= +github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E= github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/charmbracelet/bubbles v1.0.0 h1:12J8/ak/uCZEMQ6KU7pcfwceyjLlWsDLAxB5fXonfvc= +github.com/charmbracelet/bubbles v1.0.0/go.mod h1:9d/Zd5GdnauMI5ivUIVisuEm3ave1XwXtD1ckyV6r3E= +github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw= +github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4= +github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk= +github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk= +github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY= +github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30= +github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8= +github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ= +github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI= +github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q= +github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ= +github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U= +github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk= +github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI= github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM= github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ= github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI= github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk= github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04= github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8= +github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA= +github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA= +github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs= +github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA= +github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w94cO8U= +github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g= github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= 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/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ= +github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4= +github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM= github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA= @@ -59,10 +93,22 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag= +github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= +github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw= +github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs= github.com/microsoft/go-mssqldb v1.9.8 h1:d4IFMvF/o+HdpXUqbBfzHvn/NlFA75YGcfHUUvDFJEM= github.com/microsoft/go-mssqldb v1.9.8/go.mod h1:eGSRSGAW4hKMy5YcAenhCDjIRm2rhqIdmmwgciMzLus= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= +github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= +github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= +github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= @@ -73,9 +119,13 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k= github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA= +github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y= github.com/segmentio/asm v1.1.3 h1:WM03sfUOENvvKexOLp+pCqgb/WDjsi7EK8gIsICtzhc= github.com/segmentio/asm v1.1.3/go.mod h1:Ld3L4ZXGNcSLRg4JBsZ3//1+f/TjYl0Mzen/DQy1EJg= github.com/segmentio/encoding v0.3.4 h1:WM4IBnxH8B9TakiM2QD5LyNl9JSndh88QbHqVC+Pauc= @@ -93,6 +143,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= +github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.lsp.dev/jsonrpc2 v0.10.0 h1:Pr/YcXJoEOTMc/b6OTmcR1DPJ3mSWl/SWiU1Cct6VmI= go.lsp.dev/jsonrpc2 v0.10.0/go.mod h1:fmEzIdXPi/rf6d4uFcayi8HpFP1nBF99ERP1htC72Ac= @@ -141,6 +193,7 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/mdl/ast/ast_attribute.go b/mdl/ast/ast_attribute.go index 6d9b6a6..031ef74 100644 --- a/mdl/ast/ast_attribute.go +++ b/mdl/ast/ast_attribute.go @@ -16,6 +16,8 @@ type Attribute struct { UniqueError string // Custom error message for UNIQUE HasDefault bool DefaultValue any // string, int64, float64, bool, or QualifiedName for enums + Calculated bool // attribute is calculated (not stored) + CalculatedMicroflow *QualifiedName // microflow that computes the calculated value Comment string Documentation string RenamedFrom string // @RenamedFrom annotation value diff --git a/mdl/ast/ast_entity.go b/mdl/ast/ast_entity.go index 266bd97..d80d5ec 100644 --- a/mdl/ast/ast_entity.go +++ b/mdl/ast/ast_entity.go @@ -74,8 +74,10 @@ type AlterEntityStmt struct { Attribute *Attribute // For ADD ATTRIBUTE AttributeName string // For RENAME/MODIFY/DROP ATTRIBUTE NewName string // For RENAME ATTRIBUTE - DataType DataType // For MODIFY ATTRIBUTE - Documentation string // For SET DOCUMENTATION + DataType DataType // For MODIFY ATTRIBUTE + Calculated bool // For MODIFY ATTRIBUTE with CALCULATED + CalculatedMicroflow *QualifiedName // For MODIFY ATTRIBUTE with CALCULATED microflow + Documentation string // For SET DOCUMENTATION Comment string // For SET COMMENT Index *Index // For ADD INDEX IndexName string // For DROP INDEX diff --git a/mdl/ast/ast_query.go b/mdl/ast/ast_query.go index aca3468..a9e6d27 100644 --- a/mdl/ast/ast_query.go +++ b/mdl/ast/ast_query.go @@ -53,6 +53,7 @@ const ( ShowAccessOn // SHOW ACCESS ON Module.Entity ShowAccessOnMicroflow // SHOW ACCESS ON MICROFLOW Module.MF ShowAccessOnPage // SHOW ACCESS ON PAGE Module.Page + ShowAccessOnWorkflow // SHOW ACCESS ON WORKFLOW Module.WF ShowSecurityMatrix // SHOW SECURITY MATRIX [IN module] // OData show types @@ -136,6 +137,8 @@ func (t ShowObjectType) String() string { return "ACCESS ON MICROFLOW" case ShowAccessOnPage: return "ACCESS ON PAGE" + case ShowAccessOnWorkflow: + return "ACCESS ON WORKFLOW" case ShowSecurityMatrix: return "SECURITY MATRIX" case ShowODataClients: diff --git a/mdl/ast/ast_security.go b/mdl/ast/ast_security.go index 1a72db7..e0d6d1a 100644 --- a/mdl/ast/ast_security.go +++ b/mdl/ast/ast_security.go @@ -114,6 +114,22 @@ type RevokePageAccessStmt struct { func (s *RevokePageAccessStmt) isStatement() {} +// GrantWorkflowAccessStmt represents: GRANT EXECUTE ON WORKFLOW Module.WF TO role1, role2 +type GrantWorkflowAccessStmt struct { + Workflow QualifiedName + Roles []QualifiedName +} + +func (s *GrantWorkflowAccessStmt) isStatement() {} + +// RevokeWorkflowAccessStmt represents: REVOKE EXECUTE ON WORKFLOW Module.WF FROM role1, role2 +type RevokeWorkflowAccessStmt struct { + Workflow QualifiedName + Roles []QualifiedName +} + +func (s *RevokeWorkflowAccessStmt) isStatement() {} + // GrantODataServiceAccessStmt represents: GRANT ACCESS ON ODATA SERVICE Module.Svc TO role1, role2 type GrantODataServiceAccessStmt struct { Service QualifiedName @@ -140,10 +156,11 @@ type AlterProjectSecurityStmt struct { func (s *AlterProjectSecurityStmt) isStatement() {} -// CreateDemoUserStmt represents: CREATE DEMO USER 'name' PASSWORD 'pw' (Role1, Role2) +// CreateDemoUserStmt represents: CREATE DEMO USER 'name' PASSWORD 'pw' [ENTITY Module.Entity] (Role1, Role2) type CreateDemoUserStmt struct { UserName string Password string + Entity string // qualified name of user entity, e.g. "Administration.Account" UserRoles []string } diff --git a/mdl/ast/ast_workflow.go b/mdl/ast/ast_workflow.go new file mode 100644 index 0000000..baa4b49 --- /dev/null +++ b/mdl/ast/ast_workflow.go @@ -0,0 +1,172 @@ +// SPDX-License-Identifier: Apache-2.0 + +package ast + +// CreateWorkflowStmt represents: CREATE WORKFLOW Module.Name ... +type CreateWorkflowStmt struct { + Name QualifiedName + CreateOrModify bool + Documentation string + + // Context parameter entity + ParameterVar string // e.g. "$WorkflowContext" + ParameterEntity QualifiedName // e.g. Module.Entity + + // Display metadata + DisplayName string // from DISPLAY 'text' + Description string // from DESCRIPTION 'text' + ExportLevel string // "Hidden" or "API", from EXPORT LEVEL identifier + + // Optional metadata + OverviewPage QualifiedName // qualified name of overview page + DueDate string // due date expression + + // Activities + Activities []WorkflowActivityNode +} + +func (s *CreateWorkflowStmt) isStatement() {} + +// DropWorkflowStmt represents: DROP WORKFLOW Module.Name +type DropWorkflowStmt struct { + Name QualifiedName +} + +func (s *DropWorkflowStmt) isStatement() {} + +// WorkflowActivityNode is the interface for workflow activity AST nodes. +type WorkflowActivityNode interface { + workflowActivityNode() +} + +// WorkflowUserTaskNode represents a USER TASK activity. +type WorkflowUserTaskNode struct { + Name string // identifier name + Caption string // display caption + Page QualifiedName + Targeting WorkflowTargetingNode + Entity QualifiedName // user task entity + DueDate string // DUE DATE expression + Outcomes []WorkflowUserTaskOutcomeNode + IsMultiUser bool // Issue #8: true if MULTI USER TASK + BoundaryEvents []WorkflowBoundaryEventNode // Issue #7 + TaskDescription string // from DESCRIPTION 'text' +} + +func (n *WorkflowUserTaskNode) workflowActivityNode() {} + +// WorkflowTargetingNode represents user targeting strategy. +type WorkflowTargetingNode struct { + Kind string // "microflow", "xpath", or "" + Microflow QualifiedName // for microflow targeting + XPath string // for xpath targeting +} + +// WorkflowUserTaskOutcomeNode represents an outcome of a user task. +type WorkflowUserTaskOutcomeNode struct { + Caption string + Activities []WorkflowActivityNode +} + +// WorkflowCallMicroflowNode represents a CALL MICROFLOW activity. +type WorkflowCallMicroflowNode struct { + Microflow QualifiedName + Caption string + Outcomes []WorkflowConditionOutcomeNode + ParameterMappings []WorkflowParameterMappingNode // Issue #10 + BoundaryEvents []WorkflowBoundaryEventNode // Issue #7 +} + +func (n *WorkflowCallMicroflowNode) workflowActivityNode() {} + +// WorkflowCallWorkflowNode represents a CALL WORKFLOW activity. +type WorkflowCallWorkflowNode struct { + Workflow QualifiedName + Caption string + ParameterMappings []WorkflowParameterMappingNode +} + +func (n *WorkflowCallWorkflowNode) workflowActivityNode() {} + +// WorkflowDecisionNode represents a DECISION activity. +type WorkflowDecisionNode struct { + Expression string // decision expression + Caption string + Outcomes []WorkflowConditionOutcomeNode +} + +func (n *WorkflowDecisionNode) workflowActivityNode() {} + +// WorkflowConditionOutcomeNode represents an outcome of a decision or call microflow. +type WorkflowConditionOutcomeNode struct { + Value string // "True", "False", "Default", or enumeration value + Activities []WorkflowActivityNode +} + +// WorkflowParallelSplitNode represents a PARALLEL SPLIT activity. +type WorkflowParallelSplitNode struct { + Caption string + Paths []WorkflowParallelPathNode +} + +func (n *WorkflowParallelSplitNode) workflowActivityNode() {} + +// WorkflowParallelPathNode represents a path in a parallel split. +type WorkflowParallelPathNode struct { + PathNumber int + Activities []WorkflowActivityNode +} + +// WorkflowJumpToNode represents a JUMP TO activity. +type WorkflowJumpToNode struct { + Target string // name of target activity + Caption string +} + +func (n *WorkflowJumpToNode) workflowActivityNode() {} + +// WorkflowWaitForTimerNode represents a WAIT FOR TIMER activity. +type WorkflowWaitForTimerNode struct { + DelayExpression string + Caption string +} + +func (n *WorkflowWaitForTimerNode) workflowActivityNode() {} + +// WorkflowWaitForNotificationNode represents a WAIT FOR NOTIFICATION activity. +type WorkflowWaitForNotificationNode struct { + Caption string + BoundaryEvents []WorkflowBoundaryEventNode // Issue #7 +} + +func (n *WorkflowWaitForNotificationNode) workflowActivityNode() {} + +// WorkflowEndNode represents an END activity. +type WorkflowEndNode struct { + Caption string +} + +func (n *WorkflowEndNode) workflowActivityNode() {} + +// WorkflowBoundaryEventNode represents a BOUNDARY EVENT clause on a user task. +// Issue #7 +type WorkflowBoundaryEventNode struct { + EventType string // "InterruptingTimer", "NonInterruptingTimer", "Timer" + Delay string // ISO duration expression e.g. "${PT1H}" + Activities []WorkflowActivityNode // Sub-flow activities inside the boundary event +} + +// WorkflowAnnotationActivityNode represents an ANNOTATION activity in a workflow. +// Issue #9 +type WorkflowAnnotationActivityNode struct { + Text string +} + +func (n *WorkflowAnnotationActivityNode) workflowActivityNode() {} + +// WorkflowParameterMappingNode represents a parameter mapping in a CALL MICROFLOW WITH clause. +// Issue #10 +type WorkflowParameterMappingNode struct { + Parameter string // parameter name (by-name reference) + Expression string // Mendix expression string +} diff --git a/mdl/catalog/builder_modules.go b/mdl/catalog/builder_modules.go index 906a426..6bf0b05 100644 --- a/mdl/catalog/builder_modules.go +++ b/mdl/catalog/builder_modules.go @@ -198,7 +198,7 @@ func (b *Builder) buildEntities() error { isCalculated := 0 if attr.Value != nil { defaultValue = attr.Value.DefaultValue - if attr.Value.MicroflowID != "" { + if attr.Value.MicroflowName != "" || attr.Value.MicroflowID != "" { isCalculated = 1 } } diff --git a/mdl/catalog/builder_strings.go b/mdl/catalog/builder_strings.go index 497ca6d..24d364d 100644 --- a/mdl/catalog/builder_strings.go +++ b/mdl/catalog/builder_strings.go @@ -4,6 +4,7 @@ package catalog import ( "github.com/mendixlabs/mxcli/sdk/microflows" + "github.com/mendixlabs/mxcli/sdk/workflows" ) // buildStrings extracts string literals from documents into the FTS5 strings table. @@ -89,10 +90,85 @@ func (b *Builder) buildStrings() error { } } + // Extract from workflows — using cached list + wfList, err := b.cachedWorkflows() + if err == nil { + for _, wf := range wfList { + moduleID := b.hierarchy.findModuleID(wf.ContainerID) + moduleName := b.hierarchy.getModuleName(moduleID) + qn := moduleName + "." + wf.Name + + if wf.WorkflowName != "" { + insert(qn, "WORKFLOW", wf.WorkflowName, "workflow_name", moduleName) + } + if wf.WorkflowDescription != "" { + insert(qn, "WORKFLOW", wf.WorkflowDescription, "workflow_description", moduleName) + } + if wf.Documentation != "" { + insert(qn, "WORKFLOW", wf.Documentation, "documentation", moduleName) + } + + if wf.Flow != nil { + extractWorkflowFlowStrings(wf.Flow, qn, moduleName, insert) + } + } + } + b.report("strings", count) return nil } +// extractWorkflowFlowStrings extracts strings from workflow activities recursively. +func extractWorkflowFlowStrings(flow *workflows.Flow, qn, moduleName string, insert func(string, string, string, string, string)) { + for _, act := range flow.Activities { + if act.GetCaption() != "" { + insert(qn, "WORKFLOW", act.GetCaption(), "activity_caption", moduleName) + } + + switch a := act.(type) { + case *workflows.UserTask: + if a.TaskName != "" { + insert(qn, "WORKFLOW", a.TaskName, "task_name", moduleName) + } + if a.TaskDescription != "" { + insert(qn, "WORKFLOW", a.TaskDescription, "task_description", moduleName) + } + for _, outcome := range a.Outcomes { + if outcome.Caption != "" { + insert(qn, "WORKFLOW", outcome.Caption, "outcome_caption", moduleName) + } + if outcome.Flow != nil { + extractWorkflowFlowStrings(outcome.Flow, qn, moduleName, insert) + } + } + case *workflows.SystemTask: + for _, outcome := range a.Outcomes { + if f := outcome.GetFlow(); f != nil { + extractWorkflowFlowStrings(f, qn, moduleName, insert) + } + } + case *workflows.CallMicroflowTask: + for _, outcome := range a.Outcomes { + if f := outcome.GetFlow(); f != nil { + extractWorkflowFlowStrings(f, qn, moduleName, insert) + } + } + case *workflows.ExclusiveSplitActivity: + for _, outcome := range a.Outcomes { + if f := outcome.GetFlow(); f != nil { + extractWorkflowFlowStrings(f, qn, moduleName, insert) + } + } + case *workflows.ParallelSplitActivity: + for _, outcome := range a.Outcomes { + if outcome.Flow != nil { + extractWorkflowFlowStrings(outcome.Flow, qn, moduleName, insert) + } + } + } + } +} + // extractActivityStrings extracts string literals from microflow/nanoflow activities. func extractActivityStrings(oc *microflows.MicroflowObjectCollection, qn, objType, moduleName string, insert func(string, string, string, string, string)) { if oc == nil { diff --git a/mdl/executor/cmd_entities.go b/mdl/executor/cmd_entities.go index 7064e59..2b5dfcd 100644 --- a/mdl/executor/cmd_entities.go +++ b/mdl/executor/cmd_entities.go @@ -72,6 +72,11 @@ func (e *Executor) execCreateEntity(s *ast.CreateEntityStmt) error { var attrs []*domainmodel.Attribute attrNameToID := make(map[string]model.ID) for _, a := range s.Attributes { + // CALCULATED attributes are only supported on persistent entities + if a.Calculated && !persistable { + return fmt.Errorf("attribute '%s': CALCULATED attributes are only supported on persistent entities", a.Name) + } + // Use Documentation if available, fall back to Comment doc := a.Documentation if doc == "" { @@ -89,8 +94,21 @@ func (e *Executor) execCreateEntity(s *ast.CreateEntityStmt) error { } attr.ID = attrID - // Default value - if a.HasDefault { + // Value type: CALCULATED or DEFAULT + if a.Calculated { + attrValue := &domainmodel.AttributeValue{ + Type: "CalculatedValue", + } + if a.CalculatedMicroflow != nil { + mfID, err := e.resolveMicroflowByName(a.CalculatedMicroflow.String()) + if err != nil { + return fmt.Errorf("attribute '%s': %w", a.Name, err) + } + attrValue.MicroflowID = mfID + attrValue.MicroflowName = a.CalculatedMicroflow.String() + } + attr.Value = attrValue + } else if a.HasDefault { defaultStr := fmt.Sprintf("%v", a.DefaultValue) // For enum attributes, Mendix stores just the value name (e.g., "Open"), // not the fully qualified name. The EnumerationRef already provides context. @@ -393,6 +411,10 @@ func (e *Executor) execAlterEntity(s *ast.AlterEntityStmt) error { if a == nil { return fmt.Errorf("no attribute definition provided") } + // CALCULATED attributes are only supported on persistent entities + if a.Calculated && !entity.Persistable { + return fmt.Errorf("attribute '%s': CALCULATED attributes are only supported on persistent entities", a.Name) + } // Auto-default Boolean attributes to false if no DEFAULT specified if a.Type.Kind == ast.TypeBoolean && !a.HasDefault { a.HasDefault = true @@ -412,7 +434,20 @@ func (e *Executor) execAlterEntity(s *ast.AlterEntityStmt) error { Type: convertDataType(a.Type), } attr.ID = attrID - if a.HasDefault { + if a.Calculated { + attrValue := &domainmodel.AttributeValue{ + Type: "CalculatedValue", + } + if a.CalculatedMicroflow != nil { + mfID, err := e.resolveMicroflowByName(a.CalculatedMicroflow.String()) + if err != nil { + return fmt.Errorf("attribute '%s': %w", a.Name, err) + } + attrValue.MicroflowID = mfID + attrValue.MicroflowName = a.CalculatedMicroflow.String() + } + attr.Value = attrValue + } else if a.HasDefault { defaultStr := fmt.Sprintf("%v", a.DefaultValue) if a.Type.Kind == ast.TypeEnumeration && a.Type.EnumRef != nil { enumPrefix := a.Type.EnumRef.String() + "." @@ -483,10 +518,28 @@ func (e *Executor) execAlterEntity(s *ast.AlterEntityStmt) error { fmt.Fprintf(e.output, "Renamed attribute '%s' to '%s' on entity %s\n", s.AttributeName, s.NewName, s.Name) case ast.AlterEntityModifyAttribute: + // CALCULATED attributes are only supported on persistent entities + if s.Calculated && !entity.Persistable { + return fmt.Errorf("attribute '%s': CALCULATED attributes are only supported on persistent entities", s.AttributeName) + } found := false for _, attr := range entity.Attributes { if attr.Name == s.AttributeName { attr.Type = convertDataType(s.DataType) + if s.Calculated { + attrValue := &domainmodel.AttributeValue{ + Type: "CalculatedValue", + } + if s.CalculatedMicroflow != nil { + mfID, err := e.resolveMicroflowByName(s.CalculatedMicroflow.String()) + if err != nil { + return fmt.Errorf("attribute '%s': %w", s.AttributeName, err) + } + attrValue.MicroflowID = mfID + attrValue.MicroflowName = s.CalculatedMicroflow.String() + } + attr.Value = attrValue + } found = true break } @@ -1050,8 +1103,17 @@ func (e *Executor) describeEntity(name ast.QualifiedName) error { } } - // Default value - if attr.Value != nil && attr.Value.DefaultValue != "" { + // Value type: CALCULATED or DEFAULT + if attr.Value != nil && attr.Value.Type == "CalculatedValue" { + constraints.WriteString(" CALCULATED") + if attr.Value.MicroflowName != "" { + constraints.WriteString(" BY " + attr.Value.MicroflowName) + } else if attr.Value.MicroflowID != "" { + if mfName := e.lookupMicroflowName(attr.Value.MicroflowID); mfName != "" { + constraints.WriteString(" BY " + mfName) + } + } + } else if attr.Value != nil && attr.Value.DefaultValue != "" { defaultVal := attr.Value.DefaultValue // Quote string defaults if _, ok := attr.Type.(*domainmodel.StringAttributeType); ok { @@ -1290,3 +1352,67 @@ func extractAttrNameFromQualified(qualifiedName string) string { } return "" } + +// resolveMicroflowByName resolves a qualified microflow name to its ID. +// It checks both microflows created during this session and existing microflows in the project. +func (e *Executor) resolveMicroflowByName(qualifiedName string) (model.ID, error) { + parts := strings.Split(qualifiedName, ".") + if len(parts) < 2 { + return "", fmt.Errorf("invalid microflow name: %s (expected Module.Name)", qualifiedName) + } + moduleName := parts[0] + mfName := strings.Join(parts[1:], ".") + + // Check microflows created during this session + if e.cache != nil && e.cache.createdMicroflows != nil { + if info, ok := e.cache.createdMicroflows[qualifiedName]; ok { + return info.ID, nil + } + } + + // Search existing microflows + allMicroflows, err := e.reader.ListMicroflows() + if err != nil { + return "", fmt.Errorf("failed to list microflows: %w", err) + } + + h, err := e.getHierarchy() + if err != nil { + return "", fmt.Errorf("failed to build hierarchy: %w", err) + } + + for _, mf := range allMicroflows { + modID := h.FindModuleID(mf.ContainerID) + modName := h.GetModuleName(modID) + if modName == moduleName && mf.Name == mfName { + return mf.ID, nil + } + } + + return "", fmt.Errorf("microflow not found: %s", qualifiedName) +} + +// lookupMicroflowName reverse-looks up a microflow ID to its qualified name. +func (e *Executor) lookupMicroflowName(mfID model.ID) string { + allMicroflows, err := e.reader.ListMicroflows() + if err != nil { + return "" + } + + h, err := e.getHierarchy() + if err != nil { + return "" + } + + for _, mf := range allMicroflows { + if mf.ID == mfID { + modID := h.FindModuleID(mf.ContainerID) + modName := h.GetModuleName(modID) + if modName != "" { + return modName + "." + mf.Name + } + return mf.Name + } + } + return "" +} diff --git a/mdl/executor/cmd_misc.go b/mdl/executor/cmd_misc.go index 97dc627..d1d1fc1 100644 --- a/mdl/executor/cmd_misc.go +++ b/mdl/executor/cmd_misc.go @@ -206,6 +206,8 @@ Security - Access Control: REVOKE EXECUTE ON MICROFLOW Module.Name FROM Role [, Role...]; GRANT VIEW ON PAGE Module.Name TO Role [, Role...]; REVOKE VIEW ON PAGE Module.Name FROM Role [, Role...]; + GRANT EXECUTE ON WORKFLOW Module.Name TO Role [, Role...]; + REVOKE EXECUTE ON WORKFLOW Module.Name FROM Role [, Role...]; GRANT Role ON Module.Entity (CREATE, DELETE, READ *, WRITE *) [WHERE 'xpath']; REVOKE Role ON Module.Entity; @@ -222,6 +224,7 @@ Security - Queries: SHOW DEMO USERS; SHOW ACCESS ON MICROFLOW Module.Name; SHOW ACCESS ON PAGE Module.Name; + SHOW ACCESS ON WORKFLOW Module.Name; SHOW ACCESS ON Module.Entity; SHOW SECURITY MATRIX [IN Module]; DESCRIBE MODULE ROLE Module.Role; diff --git a/mdl/executor/cmd_security.go b/mdl/executor/cmd_security.go index eacb3e8..ed6bdaa 100644 --- a/mdl/executor/cmd_security.go +++ b/mdl/executor/cmd_security.go @@ -382,6 +382,40 @@ func (e *Executor) showAccessOnPage(name *ast.QualifiedName) error { return fmt.Errorf("page not found: %s", name) } +// showAccessOnWorkflow handles SHOW ACCESS ON WORKFLOW Module.WF. +func (e *Executor) showAccessOnWorkflow(name *ast.QualifiedName) error { + if name == nil { + return fmt.Errorf("workflow name required") + } + + h, err := e.getHierarchy() + if err != nil { + return fmt.Errorf("failed to build hierarchy: %w", err) + } + + wfs, err := e.reader.ListWorkflows() + if err != nil { + return fmt.Errorf("failed to list workflows: %w", err) + } + + for _, wf := range wfs { + modName := h.GetModuleName(h.FindModuleID(wf.ContainerID)) + if modName == name.Module && wf.Name == name.Name { + if len(wf.AllowedModuleRoles) == 0 { + fmt.Fprintf(e.output, "No module roles granted execute access on %s.%s\n", modName, wf.Name) + return nil + } + fmt.Fprintf(e.output, "Allowed module roles for %s.%s:\n", modName, wf.Name) + for _, role := range wf.AllowedModuleRoles { + fmt.Fprintf(e.output, " %s\n", string(role)) + } + return nil + } + } + + return fmt.Errorf("workflow not found: %s", name) +} + // showSecurityMatrix handles SHOW SECURITY MATRIX [IN module]. func (e *Executor) showSecurityMatrix(moduleName string) error { h, err := e.getHierarchy() @@ -569,6 +603,37 @@ func (e *Executor) showSecurityMatrix(moduleName string) error { } fmt.Fprintln(e.output) + // Workflow section + fmt.Fprintln(e.output, "## Workflow Access") + fmt.Fprintln(e.output) + + wfs, err := e.reader.ListWorkflows() + if err != nil { + return fmt.Errorf("failed to list workflows: %w", err) + } + + wfFound := false + for _, wf := range wfs { + if len(wf.AllowedModuleRoles) == 0 { + continue + } + modID := h.FindModuleID(wf.ContainerID) + modName := h.GetModuleName(modID) + if moduleName != "" && modName != moduleName { + continue + } + wfFound = true + var roleStrs []string + for _, r := range wf.AllowedModuleRoles { + roleStrs = append(roleStrs, string(r)) + } + fmt.Fprintf(e.output, " %s.%s: %s\n", modName, wf.Name, strings.Join(roleStrs, ", ")) + } + if !wfFound { + fmt.Fprintln(e.output, "(no workflow access rules configured)") + } + fmt.Fprintln(e.output) + return nil } @@ -633,6 +698,9 @@ func (e *Executor) describeDemoUser(userName string) error { for _, du := range ps.DemoUsers { if du.UserName == userName { fmt.Fprintf(e.output, "CREATE DEMO USER '%s' PASSWORD '***'", du.UserName) + if du.Entity != "" { + fmt.Fprintf(e.output, " ENTITY %s", du.Entity) + } if len(du.UserRoles) > 0 { fmt.Fprintf(e.output, " (%s)", strings.Join(du.UserRoles, ", ")) } diff --git a/mdl/executor/cmd_security_write.go b/mdl/executor/cmd_security_write.go index 63821c8..9ff425c 100644 --- a/mdl/executor/cmd_security_write.go +++ b/mdl/executor/cmd_security_write.go @@ -8,6 +8,7 @@ import ( "strings" "github.com/mendixlabs/mxcli/mdl/ast" + "github.com/mendixlabs/mxcli/model" "github.com/mendixlabs/mxcli/sdk/mpr" "github.com/mendixlabs/mxcli/sdk/security" ) @@ -333,6 +334,11 @@ func (e *Executor) execGrantEntityAccess(s *ast.GrantEntityAccessStmt) error { } else if readMemberSet[attr.Name] { rights = "ReadOnly" } + // Calculated attributes cannot have write rights (CE6592) + isCalculated := attr.Value != nil && attr.Value.Type == "CalculatedValue" + if isCalculated && (rights == "ReadWrite" || rights == "WriteOnly") { + rights = "ReadOnly" + } memberAccesses = append(memberAccesses, mpr.EntityMemberAccess{ AttributeRef: module.Name + "." + s.Entity.Name + "." + attr.Name, AccessRights: rights, @@ -665,6 +671,124 @@ func (e *Executor) execRevokePageAccess(s *ast.RevokePageAccessStmt) error { return fmt.Errorf("page not found: %s.%s", s.Page.Module, s.Page.Name) } +// execGrantWorkflowAccess handles GRANT EXECUTE ON WORKFLOW Module.WF TO roles. +func (e *Executor) execGrantWorkflowAccess(s *ast.GrantWorkflowAccessStmt) error { + if e.writer == nil { + return fmt.Errorf("not connected to a project in write mode") + } + + h, err := e.getHierarchy() + if err != nil { + return fmt.Errorf("failed to build hierarchy: %w", err) + } + + // Find the workflow + wfs, err := e.reader.ListWorkflows() + if err != nil { + return fmt.Errorf("failed to list workflows: %w", err) + } + + for _, wf := range wfs { + modID := h.FindModuleID(wf.ContainerID) + modName := h.GetModuleName(modID) + if modName != s.Workflow.Module || wf.Name != s.Workflow.Name { + continue + } + + // Validate all roles exist + for _, role := range s.Roles { + if err := e.validateModuleRole(role); err != nil { + return err + } + } + + // Merge new roles with existing (skip duplicates) + existing := make(map[string]bool) + var merged []string + for _, r := range wf.AllowedModuleRoles { + existing[string(r)] = true + merged = append(merged, string(r)) + } + var added []string + for _, role := range s.Roles { + qn := role.Module + "." + role.Name + if !existing[qn] { + merged = append(merged, qn) + added = append(added, qn) + } + } + + if err := e.writer.UpdateAllowedRoles(wf.ID, merged); err != nil { + return fmt.Errorf("failed to update workflow access: %w", err) + } + + if len(added) == 0 { + fmt.Fprintf(e.output, "All specified roles already have execute access on %s.%s\n", modName, wf.Name) + } else { + fmt.Fprintf(e.output, "Granted execute access on %s.%s to %s\n", modName, wf.Name, strings.Join(added, ", ")) + } + return nil + } + + return fmt.Errorf("workflow not found: %s.%s", s.Workflow.Module, s.Workflow.Name) +} + +// execRevokeWorkflowAccess handles REVOKE EXECUTE ON WORKFLOW Module.WF FROM roles. +func (e *Executor) execRevokeWorkflowAccess(s *ast.RevokeWorkflowAccessStmt) error { + if e.writer == nil { + return fmt.Errorf("not connected to a project in write mode") + } + + h, err := e.getHierarchy() + if err != nil { + return fmt.Errorf("failed to build hierarchy: %w", err) + } + + // Find the workflow + wfs, err := e.reader.ListWorkflows() + if err != nil { + return fmt.Errorf("failed to list workflows: %w", err) + } + + for _, wf := range wfs { + modID := h.FindModuleID(wf.ContainerID) + modName := h.GetModuleName(modID) + if modName != s.Workflow.Module || wf.Name != s.Workflow.Name { + continue + } + + // Build set of roles to remove + toRemove := make(map[string]bool) + for _, role := range s.Roles { + toRemove[role.Module+"."+role.Name] = true + } + + // Filter out removed roles + var remaining []string + var removed []string + for _, r := range wf.AllowedModuleRoles { + if toRemove[string(r)] { + removed = append(removed, string(r)) + } else { + remaining = append(remaining, string(r)) + } + } + + if err := e.writer.UpdateAllowedRoles(wf.ID, remaining); err != nil { + return fmt.Errorf("failed to update workflow access: %w", err) + } + + if len(removed) == 0 { + fmt.Fprintf(e.output, "None of the specified roles had execute access on %s.%s\n", modName, wf.Name) + } else { + fmt.Fprintf(e.output, "Revoked execute access on %s.%s from %s\n", modName, wf.Name, strings.Join(removed, ", ")) + } + return nil + } + + return fmt.Errorf("workflow not found: %s.%s", s.Workflow.Module, s.Workflow.Name) +} + // validateModuleRole checks that a module role exists in the project. func (e *Executor) validateModuleRole(role ast.QualifiedName) error { module, err := e.findModule(role.Module) @@ -731,7 +855,7 @@ func (e *Executor) execAlterProjectSecurity(s *ast.AlterProjectSecurityStmt) err return nil } -// execCreateDemoUser handles CREATE DEMO USER 'name' PASSWORD 'pw' (Roles). +// execCreateDemoUser handles CREATE DEMO USER 'name' PASSWORD 'pw' [ENTITY Module.Entity] (Roles). func (e *Executor) execCreateDemoUser(s *ast.CreateDemoUserStmt) error { if e.writer == nil { return fmt.Errorf("not connected to a project in write mode") @@ -749,14 +873,68 @@ func (e *Executor) execCreateDemoUser(s *ast.CreateDemoUserStmt) error { } } - if err := e.writer.AddDemoUser(ps.ID, s.UserName, s.Password, s.UserRoles); err != nil { + // Resolve entity: use explicit value or auto-detect from domain models + entity := s.Entity + if entity == "" { + detected, err := e.detectUserEntity() + if err != nil { + return err + } + entity = detected + } + + if err := e.writer.AddDemoUser(ps.ID, s.UserName, s.Password, entity, s.UserRoles); err != nil { return fmt.Errorf("failed to create demo user: %w", err) } - fmt.Fprintf(e.output, "Created demo user: %s\n", s.UserName) + fmt.Fprintf(e.output, "Created demo user: %s (entity: %s)\n", s.UserName, entity) return nil } +// detectUserEntity finds the entity that generalizes System.User. +func (e *Executor) detectUserEntity() (string, error) { + modules, err := e.reader.ListModules() + if err != nil { + return "", fmt.Errorf("failed to list modules: %w", err) + } + moduleNameByID := make(map[model.ID]string, len(modules)) + for _, m := range modules { + moduleNameByID[m.ID] = m.Name + } + + dms, err := e.reader.ListDomainModels() + if err != nil { + return "", fmt.Errorf("failed to list domain models: %w", err) + } + + var candidates []string + for _, dm := range dms { + moduleName := moduleNameByID[dm.ContainerID] + for _, ent := range dm.Entities { + if ent.GeneralizationRef == "System.User" { + candidates = append(candidates, moduleName+"."+ent.Name) + } + } + } + + switch len(candidates) { + case 0: + return "", fmt.Errorf("no entity found that generalizes System.User; use ENTITY clause to specify one") + case 1: + return candidates[0], nil + default: + return "", fmt.Errorf("multiple entities generalize System.User: %s; use ENTITY clause to specify one", joinCandidates(candidates)) + } +} + +func joinCandidates(candidates []string) string { + result := candidates[0] + for i := 1; i < len(candidates); i++ { + result += ", " + candidates[i] + } + return result +} + // execDropDemoUser handles DROP DEMO USER 'name'. func (e *Executor) execDropDemoUser(s *ast.DropDemoUserStmt) error { if e.writer == nil { diff --git a/mdl/executor/cmd_structure.go b/mdl/executor/cmd_structure.go index 8f6979a..52cfae8 100644 --- a/mdl/executor/cmd_structure.go +++ b/mdl/executor/cmd_structure.go @@ -1015,7 +1015,7 @@ func formatAttributeWithType(attr *domainmodel.Attribute) string { if t.Length > 0 { return fmt.Sprintf("%s: String(%d)", attr.Name, t.Length) } - return attr.Name + ": String" + return attr.Name + ": String(unlimited)" case *domainmodel.EnumerationAttributeType: return attr.Name + ": " + shortName(t.EnumerationRef) default: diff --git a/mdl/executor/cmd_workflows.go b/mdl/executor/cmd_workflows.go index a011816..5b49985 100644 --- a/mdl/executor/cmd_workflows.go +++ b/mdl/executor/cmd_workflows.go @@ -209,11 +209,8 @@ func (e *Executor) describeWorkflowToString(name ast.QualifiedName) (string, map // Header lines = append(lines, fmt.Sprintf("-- Workflow: %s", qualifiedName)) - if targetWf.WorkflowName != "" { - lines = append(lines, fmt.Sprintf("-- Display Name: %s", targetWf.WorkflowName)) - } - if targetWf.WorkflowDescription != "" { - lines = append(lines, fmt.Sprintf("-- Description: %s", targetWf.WorkflowDescription)) + if targetWf.Annotation != "" { + lines = append(lines, fmt.Sprintf("-- %s", targetWf.Annotation)) } lines = append(lines, "") @@ -224,6 +221,23 @@ func (e *Executor) describeWorkflowToString(name ast.QualifiedName) (string, map lines = append(lines, fmt.Sprintf(" PARAMETER $WorkflowContext: %s", targetWf.Parameter.EntityRef)) } + // Display name + if targetWf.WorkflowName != "" { + escaped := strings.ReplaceAll(targetWf.WorkflowName, "'", "''") + lines = append(lines, fmt.Sprintf(" DISPLAY '%s'", escaped)) + } + + // Description + if targetWf.WorkflowDescription != "" { + escaped := strings.ReplaceAll(targetWf.WorkflowDescription, "'", "''") + lines = append(lines, fmt.Sprintf(" DESCRIPTION '%s'", escaped)) + } + + // Export level (only emit when non-empty) + if targetWf.ExportLevel != "" { + lines = append(lines, fmt.Sprintf(" EXPORT LEVEL %s", targetWf.ExportLevel)) + } + // Overview page if targetWf.OverviewPage != "" { lines = append(lines, fmt.Sprintf(" OVERVIEW PAGE %s", targetWf.OverviewPage)) @@ -236,6 +250,7 @@ func (e *Executor) describeWorkflowToString(name ast.QualifiedName) (string, map lines = append(lines, "") + lines = append(lines, "BEGIN") // Activities if targetWf.Flow != nil { actLines := formatWorkflowActivities(targetWf.Flow, " ") @@ -248,6 +263,54 @@ func (e *Executor) describeWorkflowToString(name ast.QualifiedName) (string, map return strings.Join(lines, "\n"), nil, nil } +// formatAnnotation returns an ANNOTATION statement for a workflow activity annotation. +// The annotation is emitted as a parseable MDL statement so it survives round-trips. +func formatAnnotation(annotation string, indent string) string { + if annotation == "" { + return "" + } + escaped := strings.ReplaceAll(annotation, "'", "''") + return fmt.Sprintf("%sANNOTATION '%s';", indent, escaped) +} + +// boundaryEventKeyword maps an EventType string to the MDL BOUNDARY EVENT keyword sequence. +func boundaryEventKeyword(eventType string) string { + switch eventType { + case "InterruptingTimer": + return "BOUNDARY EVENT INTERRUPTING TIMER" + case "NonInterruptingTimer": + return "BOUNDARY EVENT NON INTERRUPTING TIMER" + default: + return "BOUNDARY EVENT TIMER" + } +} + +// formatBoundaryEvents formats boundary events for describe output. +func formatBoundaryEvents(events []*workflows.BoundaryEvent, indent string) []string { + if len(events) == 0 { + return nil + } + + var lines []string + for _, event := range events { + keyword := boundaryEventKeyword(event.EventType) + if event.TimerDelay != "" { + escapedDelay := strings.ReplaceAll(event.TimerDelay, "'", "''") + lines = append(lines, fmt.Sprintf("%s%s '%s'", indent, keyword, escapedDelay)) + } else { + lines = append(lines, fmt.Sprintf("%s%s", indent, keyword)) + } + if event.Flow != nil && len(event.Flow.Activities) > 0 { + lines = append(lines, fmt.Sprintf("%s{", indent)) + subLines := formatWorkflowActivities(event.Flow, indent+" ") + lines = append(lines, subLines...) + lines = append(lines, fmt.Sprintf("%s}", indent)) + } + } + + return lines +} + // formatWorkflowActivities generates MDL-like output for workflow activities. func formatWorkflowActivities(flow *workflows.Flow, indent string) []string { if flow == nil { @@ -256,19 +319,21 @@ func formatWorkflowActivities(flow *workflows.Flow, indent string) []string { var lines []string for _, act := range flow.Activities { + var actLines []string + isComment := false switch a := act.(type) { case *workflows.UserTask: - lines = append(lines, formatUserTask(a, indent)...) + actLines = formatUserTask(a, indent) case *workflows.CallMicroflowTask: - lines = append(lines, formatCallMicroflowTask(a, indent)...) + actLines = formatCallMicroflowTask(a, indent) case *workflows.SystemTask: - lines = append(lines, formatSystemTask(a, indent)...) + actLines = formatSystemTask(a, indent) case *workflows.CallWorkflowActivity: - lines = append(lines, formatCallWorkflowActivity(a, indent)...) + actLines = formatCallWorkflowActivity(a, indent) case *workflows.ExclusiveSplitActivity: - lines = append(lines, formatExclusiveSplit(a, indent)...) + actLines = formatExclusiveSplit(a, indent) case *workflows.ParallelSplitActivity: - lines = append(lines, formatParallelSplit(a, indent)...) + actLines = formatParallelSplit(a, indent) case *workflows.JumpToActivity: target := a.TargetActivity if target == "" { @@ -278,42 +343,80 @@ func formatWorkflowActivities(flow *workflows.Flow, indent string) []string { if caption == "" { caption = a.Name } - lines = append(lines, fmt.Sprintf("%sJUMP TO %s -- %s", indent, target, caption)) + if a.Annotation != "" { + actLines = append(actLines, formatAnnotation(a.Annotation, indent)) + } + escapedCaption := strings.ReplaceAll(caption, "'", "''") + actLines = append(actLines, fmt.Sprintf("%sJUMP TO %s COMMENT '%s'", indent, target, escapedCaption)) case *workflows.WaitForTimerActivity: caption := a.Caption if caption == "" { caption = a.Name } + if a.Annotation != "" { + actLines = append(actLines, formatAnnotation(a.Annotation, indent)) + } if a.DelayExpression != "" { - lines = append(lines, fmt.Sprintf("%sWAIT FOR TIMER '%s' -- %s", indent, a.DelayExpression, caption)) + escapedDelay := strings.ReplaceAll(a.DelayExpression, "'", "''") + escapedCaption := strings.ReplaceAll(caption, "'", "''") + actLines = append(actLines, fmt.Sprintf("%sWAIT FOR TIMER '%s' COMMENT '%s'", indent, escapedDelay, escapedCaption)) } else { - lines = append(lines, fmt.Sprintf("%sWAIT FOR TIMER -- %s", indent, caption)) + escapedCaption := strings.ReplaceAll(caption, "'", "''") + actLines = append(actLines, fmt.Sprintf("%sWAIT FOR TIMER COMMENT '%s'", indent, escapedCaption)) } case *workflows.WaitForNotificationActivity: caption := a.Caption if caption == "" { caption = a.Name } - lines = append(lines, fmt.Sprintf("%sWAIT FOR NOTIFICATION -- %s", indent, caption)) - case *workflows.EndWorkflowActivity: - caption := a.Caption - if caption == "" { - caption = a.Name + if a.Annotation != "" { + actLines = append(actLines, formatAnnotation(a.Annotation, indent)) } - if caption != "" { - lines = append(lines, fmt.Sprintf("%sEND -- %s", indent, caption)) + actLines = append(actLines, fmt.Sprintf("%sWAIT FOR NOTIFICATION -- %s", indent, caption)) + // BoundaryEvents + actLines = append(actLines, formatBoundaryEvents(a.BoundaryEvents, indent+" ")...) + case *workflows.StartWorkflowActivity: + // Skip start activities - they are implicit + continue + case *workflows.EndWorkflowActivity: + // Skip end activities - they are implicit + continue + case *workflows.EndOfParallelSplitPathActivity: + // Skip - auto-generated by Mendix, implicit in MDL syntax + continue + case *workflows.EndOfBoundaryEventPathActivity: + // Skip - auto-generated by Mendix, implicit in MDL syntax + continue + case *workflows.WorkflowAnnotationActivity: + // Standalone annotation (sticky note) - emit as ANNOTATION statement + if a.Description != "" { + escapedDesc := strings.ReplaceAll(a.Description, "'", "''") + actLines = []string{fmt.Sprintf("%sANNOTATION '%s'", indent, escapedDesc)} } else { - lines = append(lines, fmt.Sprintf("%sEND", indent)) + continue } case *workflows.GenericWorkflowActivity: + isComment = true caption := a.Caption if caption == "" { caption = a.Name } - lines = append(lines, fmt.Sprintf("%s-- [%s] %s", indent, a.TypeString, caption)) + actLines = []string{fmt.Sprintf("%s-- [%s] %s", indent, a.TypeString, caption)} default: - lines = append(lines, fmt.Sprintf("%s-- [unknown activity]", indent)) + isComment = true + actLines = []string{fmt.Sprintf("%s-- [unknown activity]", indent)} + } + // Append semicolon to last line of activity (not for comments) + // Insert before any -- comment to avoid the comment swallowing the semicolon + if !isComment && len(actLines) > 0 { + lastLine := actLines[len(actLines)-1] + if idx := strings.Index(lastLine, " -- "); idx >= 0 { + actLines[len(actLines)-1] = lastLine[:idx] + ";" + lastLine[idx:] + } else { + actLines[len(actLines)-1] = lastLine + ";" + } } + lines = append(lines, actLines...) lines = append(lines, "") } @@ -323,6 +426,11 @@ func formatWorkflowActivities(flow *workflows.Flow, indent string) []string { // formatUserTask formats a user task for describe output. func formatUserTask(a *workflows.UserTask, indent string) []string { var lines []string + + if a.Annotation != "" { + lines = append(lines, formatAnnotation(a.Annotation, indent)) + } + caption := a.Caption if caption == "" { caption = a.Name @@ -332,7 +440,11 @@ func formatUserTask(a *workflows.UserTask, indent string) []string { nameStr = "unnamed" } - lines = append(lines, fmt.Sprintf("%sUSER TASK %s '%s'", indent, nameStr, caption)) + taskKeyword := "USER TASK" + if a.IsMulti { + taskKeyword = "MULTI USER TASK" + } + lines = append(lines, fmt.Sprintf("%s%s %s '%s'", indent, taskKeyword, nameStr, caption)) if a.Page != "" { lines = append(lines, fmt.Sprintf("%s PAGE %s", indent, a.Page)) @@ -356,28 +468,54 @@ func formatUserTask(a *workflows.UserTask, indent string) []string { lines = append(lines, fmt.Sprintf("%s ENTITY %s", indent, a.UserTaskEntity)) } + // Due date (task-level) + if a.DueDate != "" { + escapedDueDate := strings.ReplaceAll(a.DueDate, "'", "''") + lines = append(lines, fmt.Sprintf("%s DUE DATE '%s'", indent, escapedDueDate)) + } + + // Task description + if a.TaskDescription != "" { + escaped := strings.ReplaceAll(a.TaskDescription, "'", "''") + lines = append(lines, fmt.Sprintf("%s DESCRIPTION '%s'", indent, escaped)) + } + // Outcomes if len(a.Outcomes) > 0 { lines = append(lines, fmt.Sprintf("%s OUTCOMES", indent)) for _, outcome := range a.Outcomes { - outCaption := outcome.Caption - if outCaption == "" { - outCaption = outcome.Name + outValue := outcome.Value + if outValue == "" { + outValue = outcome.Caption + } + if outValue == "" { + outValue = outcome.Name } - lines = append(lines, fmt.Sprintf("%s '%s'", indent, outCaption)) if outcome.Flow != nil && len(outcome.Flow.Activities) > 0 { + lines = append(lines, fmt.Sprintf("%s '%s' {", indent, outValue)) subLines := formatWorkflowActivities(outcome.Flow, indent+" ") lines = append(lines, subLines...) + lines = append(lines, fmt.Sprintf("%s }", indent)) + } else { + lines = append(lines, fmt.Sprintf("%s '%s' { }", indent, outValue)) } } } + // BoundaryEvents + lines = append(lines, formatBoundaryEvents(a.BoundaryEvents, indent+" ")...) + return lines } // formatCallMicroflowTask formats a call microflow task for describe output. func formatCallMicroflowTask(a *workflows.CallMicroflowTask, indent string) []string { var lines []string + + if a.Annotation != "" { + lines = append(lines, formatAnnotation(a.Annotation, indent)) + } + caption := a.Caption if caption == "" { caption = a.Name @@ -388,7 +526,22 @@ func formatCallMicroflowTask(a *workflows.CallMicroflowTask, indent string) []st mf = "?" } - lines = append(lines, fmt.Sprintf("%sCALL MICROFLOW %s -- %s", indent, mf, caption)) + if len(a.ParameterMappings) > 0 { + var params []string + for _, pm := range a.ParameterMappings { + paramName := pm.Parameter + if idx := strings.LastIndex(paramName, "."); idx >= 0 { + paramName = paramName[idx+1:] + } + params = append(params, fmt.Sprintf("%s = '%s'", paramName, strings.ReplaceAll(pm.Expression, "'", "''"))) + } + lines = append(lines, fmt.Sprintf("%sCALL MICROFLOW %s WITH (%s) -- %s", indent, mf, strings.Join(params, ", "), caption)) + } else { + lines = append(lines, fmt.Sprintf("%sCALL MICROFLOW %s -- %s", indent, mf, caption)) + } + + // BoundaryEvents + lines = append(lines, formatBoundaryEvents(a.BoundaryEvents, indent+" ")...) // Outcomes lines = append(lines, formatConditionOutcomes(a.Outcomes, indent)...) @@ -399,6 +552,11 @@ func formatCallMicroflowTask(a *workflows.CallMicroflowTask, indent string) []st // formatSystemTask formats a system task for describe output. func formatSystemTask(a *workflows.SystemTask, indent string) []string { var lines []string + + if a.Annotation != "" { + lines = append(lines, formatAnnotation(a.Annotation, indent)) + } + caption := a.Caption if caption == "" { caption = a.Name @@ -420,6 +578,11 @@ func formatSystemTask(a *workflows.SystemTask, indent string) []string { // formatCallWorkflowActivity formats a call workflow activity for describe output. func formatCallWorkflowActivity(a *workflows.CallWorkflowActivity, indent string) []string { var lines []string + + if a.Annotation != "" { + lines = append(lines, formatAnnotation(a.Annotation, indent)) + } + caption := a.Caption if caption == "" { caption = a.Name @@ -430,20 +593,43 @@ func formatCallWorkflowActivity(a *workflows.CallWorkflowActivity, indent string wf = "?" } - lines = append(lines, fmt.Sprintf("%sCALL WORKFLOW %s -- %s", indent, wf, caption)) + escapedCaption := strings.ReplaceAll(caption, "'", "''") + if len(a.ParameterMappings) > 0 { + var params []string + for _, pm := range a.ParameterMappings { + paramName := pm.Parameter + if idx := strings.LastIndex(paramName, "."); idx >= 0 { + paramName = paramName[idx+1:] + } + params = append(params, fmt.Sprintf("%s = '%s'", paramName, strings.ReplaceAll(pm.Expression, "'", "''"))) + } + lines = append(lines, fmt.Sprintf("%sCALL WORKFLOW %s COMMENT '%s' WITH (%s)", indent, wf, escapedCaption, strings.Join(params, ", "))) + } else { + lines = append(lines, fmt.Sprintf("%sCALL WORKFLOW %s COMMENT '%s'", indent, wf, escapedCaption)) + } + + // BoundaryEvents + lines = append(lines, formatBoundaryEvents(a.BoundaryEvents, indent+" ")...) + return lines } // formatExclusiveSplit formats an exclusive split (decision) for describe output. func formatExclusiveSplit(a *workflows.ExclusiveSplitActivity, indent string) []string { var lines []string + + if a.Annotation != "" { + lines = append(lines, formatAnnotation(a.Annotation, indent)) + } + caption := a.Caption if caption == "" { caption = a.Name } if a.Expression != "" { - lines = append(lines, fmt.Sprintf("%sDECISION '%s' -- %s", indent, a.Expression, caption)) + escapedExpr := strings.ReplaceAll(a.Expression, "'", "''") + lines = append(lines, fmt.Sprintf("%sDECISION '%s' -- %s", indent, escapedExpr, caption)) } else { lines = append(lines, fmt.Sprintf("%sDECISION -- %s", indent, caption)) } @@ -456,6 +642,11 @@ func formatExclusiveSplit(a *workflows.ExclusiveSplitActivity, indent string) [] // formatParallelSplit formats a parallel split for describe output. func formatParallelSplit(a *workflows.ParallelSplitActivity, indent string) []string { var lines []string + + if a.Annotation != "" { + lines = append(lines, formatAnnotation(a.Annotation, indent)) + } + caption := a.Caption if caption == "" { caption = a.Name @@ -463,11 +654,12 @@ func formatParallelSplit(a *workflows.ParallelSplitActivity, indent string) []st lines = append(lines, fmt.Sprintf("%sPARALLEL SPLIT -- %s", indent, caption)) for i, outcome := range a.Outcomes { - lines = append(lines, fmt.Sprintf("%s PATH %d", indent, i+1)) + lines = append(lines, fmt.Sprintf("%s PATH %d {", indent, i+1)) if outcome.Flow != nil && len(outcome.Flow.Activities) > 0 { subLines := formatWorkflowActivities(outcome.Flow, indent+" ") lines = append(lines, subLines...) } + lines = append(lines, fmt.Sprintf("%s }", indent)) } return lines @@ -484,10 +676,13 @@ func formatConditionOutcomes(outcomes []workflows.ConditionOutcome, indent strin for _, outcome := range outcomes { name := outcome.GetName() flow := outcome.GetFlow() - lines = append(lines, fmt.Sprintf("%s %s ->", indent, name)) if flow != nil && len(flow.Activities) > 0 { + lines = append(lines, fmt.Sprintf("%s %s -> {", indent, name)) subLines := formatWorkflowActivities(flow, indent+" ") lines = append(lines, subLines...) + lines = append(lines, fmt.Sprintf("%s }", indent)) + } else { + lines = append(lines, fmt.Sprintf("%s %s -> { }", indent, name)) } } diff --git a/mdl/executor/cmd_workflows_describe_test.go b/mdl/executor/cmd_workflows_describe_test.go new file mode 100644 index 0000000..277214e --- /dev/null +++ b/mdl/executor/cmd_workflows_describe_test.go @@ -0,0 +1,199 @@ +// SPDX-License-Identifier: Apache-2.0 + +package executor + +import ( + "strings" + "testing" + + "github.com/mendixlabs/mxcli/sdk/workflows" +) + +// formatSingleActivity is a test helper that wraps a single activity in a Flow +// and runs formatWorkflowActivities to get the DESCRIBE output. +func formatSingleActivity(act workflows.WorkflowActivity, indent string) []string { + flow := &workflows.Flow{ + Activities: []workflows.WorkflowActivity{act}, + } + return formatWorkflowActivities(flow, indent) +} + +// --- P0: strip Module.Microflow prefix from parameter names --- + +func TestFormatCallMicroflowTask_ParameterNameStripping(t *testing.T) { + tests := []struct { + name string + paramName string + wantParamName string + }{ + { + name: "three-segment name strips prefix", + paramName: "WorkflowBaseline.CallMF.Entity", + wantParamName: "Entity", + }, + { + name: "two-segment name strips prefix", + paramName: "CallMF.Entity", + wantParamName: "Entity", + }, + { + name: "single-segment name unchanged", + paramName: "Entity", + wantParamName: "Entity", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + task := &workflows.CallMicroflowTask{ + Microflow: "Module.SomeMicroflow", + ParameterMappings: []*workflows.ParameterMapping{ + {Parameter: tc.paramName, Expression: "$WorkflowContext"}, + }, + } + task.Name = "callMfTask" + task.Caption = "Call MF" + + lines := formatCallMicroflowTask(task, " ") + output := strings.Join(lines, "\n") + + wantFragment := tc.wantParamName + " = " + if !strings.Contains(output, wantFragment) { + t.Errorf("expected output to contain %q, got:\n%s", wantFragment, output) + } + + // Ensure the full qualified prefix is NOT in the parameter position + if tc.paramName != tc.wantParamName && strings.Contains(output, tc.paramName+" = ") { + t.Errorf("output should NOT contain full qualified name %q as parameter, got:\n%s", tc.paramName, output) + } + }) + } +} + +// --- P2a: DESCRIBE outputs Caption with COMMENT 'caption' format --- + +func TestFormatJumpTo_CaptionCommentFormat(t *testing.T) { + tests := []struct { + name string + caption string + actName string + want string + }{ + { + name: "caption used over name", + caption: "Go Back to Review", + actName: "jumpAct1", + want: "JUMP TO target1 COMMENT 'Go Back to Review'", + }, + { + name: "name fallback when caption empty", + caption: "", + actName: "jumpAct1", + want: "JUMP TO target1 COMMENT 'jumpAct1'", + }, + { + name: "caption with single quote escaped", + caption: "it's done", + actName: "jumpAct1", + want: "JUMP TO target1 COMMENT 'it''s done'", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + activity := &workflows.JumpToActivity{ + TargetActivity: "target1", + } + activity.Name = tc.actName + activity.Caption = tc.caption + + lines := formatSingleActivity(activity, "") + output := strings.Join(lines, "\n") + + if !strings.Contains(output, tc.want) { + t.Errorf("expected output to contain %q, got:\n%s", tc.want, output) + } + }) + } +} + +func TestFormatWaitForTimer_CaptionCommentFormat(t *testing.T) { + tests := []struct { + name string + caption string + actName string + delay string + want string + }{ + { + name: "caption with delay", + caption: "Wait 2 Hours", + actName: "waitAct1", + delay: "${PT2H}", + want: "WAIT FOR TIMER '${PT2H}' COMMENT 'Wait 2 Hours'", + }, + { + name: "name fallback no delay", + caption: "", + actName: "waitAct1", + delay: "", + want: "WAIT FOR TIMER COMMENT 'waitAct1'", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + activity := &workflows.WaitForTimerActivity{ + DelayExpression: tc.delay, + } + activity.Name = tc.actName + activity.Caption = tc.caption + + lines := formatSingleActivity(activity, "") + output := strings.Join(lines, "\n") + + if !strings.Contains(output, tc.want) { + t.Errorf("expected output to contain %q, got:\n%s", tc.want, output) + } + }) + } +} + +func TestFormatCallWorkflowActivity_CaptionCommentFormat(t *testing.T) { + tests := []struct { + name string + caption string + actName string + want string + }{ + { + name: "caption used", + caption: "Run Sub-Workflow", + actName: "callWf1", + want: "CALL WORKFLOW Module.SubFlow COMMENT 'Run Sub-Workflow'", + }, + { + name: "name fallback", + caption: "", + actName: "callWf1", + want: "CALL WORKFLOW Module.SubFlow COMMENT 'callWf1'", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + activity := &workflows.CallWorkflowActivity{ + Workflow: "Module.SubFlow", + } + activity.Name = tc.actName + activity.Caption = tc.caption + + lines := formatCallWorkflowActivity(activity, "") + output := strings.Join(lines, "\n") + + if !strings.Contains(output, tc.want) { + t.Errorf("expected output to contain %q, got:\n%s", tc.want, output) + } + }) + } +} diff --git a/mdl/executor/cmd_workflows_write.go b/mdl/executor/cmd_workflows_write.go new file mode 100644 index 0000000..9b57cca --- /dev/null +++ b/mdl/executor/cmd_workflows_write.go @@ -0,0 +1,745 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Package executor - CREATE/DROP WORKFLOW commands +package executor + +import ( + "fmt" + "strings" + "unicode" + + "github.com/mendixlabs/mxcli/mdl/ast" + "github.com/mendixlabs/mxcli/model" + "github.com/mendixlabs/mxcli/sdk/mpr" + "github.com/mendixlabs/mxcli/sdk/workflows" +) + +// execCreateWorkflow handles CREATE WORKFLOW statements. +func (e *Executor) execCreateWorkflow(s *ast.CreateWorkflowStmt) error { + if e.writer == nil { + return fmt.Errorf("not connected to a project") + } + + module, err := e.findModule(s.Name.Module) + if err != nil { + return err + } + + // Check if workflow already exists + h, err := e.getHierarchy() + if err != nil { + return fmt.Errorf("failed to build hierarchy: %w", err) + } + + existingWorkflows, err := e.reader.ListWorkflows() + if err != nil { + return fmt.Errorf("failed to list workflows: %w", err) + } + + var existingID model.ID + for _, existing := range existingWorkflows { + modID := h.FindModuleID(existing.ContainerID) + modName := h.GetModuleName(modID) + if modName == s.Name.Module && existing.Name == s.Name.Name { + if !s.CreateOrModify { + return fmt.Errorf("workflow '%s.%s' already exists (use CREATE OR REPLACE to overwrite)", s.Name.Module, s.Name.Name) + } + existingID = existing.ID + break + } + } + + wf := &workflows.Workflow{} + wf.ContainerID = module.ID + wf.Name = s.Name.Name + wf.Documentation = s.Documentation + + // Parameter + if s.ParameterEntity.Module != "" { + wf.Parameter = &workflows.WorkflowParameter{ + EntityRef: s.ParameterEntity.Module + "." + s.ParameterEntity.Name, + } + wf.Parameter.ID = model.ID(generateWorkflowUUID()) + } + + // Overview page + if s.OverviewPage.Module != "" { + wf.OverviewPage = s.OverviewPage.Module + "." + s.OverviewPage.Name + } + + // Display metadata + wf.WorkflowName = s.DisplayName + wf.WorkflowDescription = s.Description + if s.ExportLevel != "" { + wf.ExportLevel = s.ExportLevel + } + + // Due date + wf.DueDate = s.DueDate + + // Build activities with implicit start/end + flow := &workflows.Flow{} + flow.ID = model.ID(generateWorkflowUUID()) + + // Add implicit start activity + startAct := &workflows.StartWorkflowActivity{} + startAct.ID = model.ID(generateWorkflowUUID()) + startAct.Caption = "Start" + startAct.Name = "Start" + + // Add implicit end activity + endAct := &workflows.EndWorkflowActivity{} + endAct.ID = model.ID(generateWorkflowUUID()) + endAct.Caption = "End" + endAct.Name = "End" + + // Build user-defined activities + userActivities := buildWorkflowActivities(s.Activities) + + // Auto-bind microflow/workflow parameters and sanitize names + e.autoBindWorkflowParameters(userActivities) + + // Deduplicate activity names to avoid CE0495 + deduplicateActivityNames(userActivities) + + // Compose: start + user activities + end + flow.Activities = make([]workflows.WorkflowActivity, 0, len(userActivities)+2) + flow.Activities = append(flow.Activities, startAct) + flow.Activities = append(flow.Activities, userActivities...) + flow.Activities = append(flow.Activities, endAct) + + wf.Flow = flow + + if existingID != "" { + // Delete existing and recreate + if err := e.writer.DeleteWorkflow(existingID); err != nil { + return fmt.Errorf("failed to delete existing workflow: %w", err) + } + } + + if err := e.writer.CreateWorkflow(wf); err != nil { + return fmt.Errorf("failed to create workflow: %w", err) + } + + e.invalidateHierarchy() + fmt.Fprintf(e.output, "Created workflow: %s.%s\n", s.Name.Module, s.Name.Name) + return nil +} + +// execDropWorkflow handles DROP WORKFLOW statements. +func (e *Executor) execDropWorkflow(s *ast.DropWorkflowStmt) error { + if e.writer == nil { + return fmt.Errorf("not connected to a project") + } + + h, err := e.getHierarchy() + if err != nil { + return fmt.Errorf("failed to build hierarchy: %w", err) + } + + wfs, err := e.reader.ListWorkflows() + if err != nil { + return fmt.Errorf("failed to list workflows: %w", err) + } + + for _, wf := range wfs { + modID := h.FindModuleID(wf.ContainerID) + modName := h.GetModuleName(modID) + if modName == s.Name.Module && wf.Name == s.Name.Name { + if err := e.writer.DeleteWorkflow(wf.ID); err != nil { + return fmt.Errorf("failed to delete workflow: %w", err) + } + e.invalidateHierarchy() + fmt.Fprintf(e.output, "Dropped workflow: %s.%s\n", s.Name.Module, s.Name.Name) + return nil + } + } + + return fmt.Errorf("workflow not found: %s.%s", s.Name.Module, s.Name.Name) +} + +// generateWorkflowUUID generates a UUID for workflow elements. +func generateWorkflowUUID() string { + return mpr.GenerateID() +} + +// buildWorkflowActivities converts AST activity nodes to SDK workflow activities. +func buildWorkflowActivities(nodes []ast.WorkflowActivityNode) []workflows.WorkflowActivity { + var activities []workflows.WorkflowActivity + for _, node := range nodes { + act := buildWorkflowActivity(node) + if act != nil { + activities = append(activities, act) + } + } + return activities +} + +// buildBoundaryEvents converts AST boundary event nodes to SDK boundary events. +func buildBoundaryEvents(nodes []ast.WorkflowBoundaryEventNode) []*workflows.BoundaryEvent { + var events []*workflows.BoundaryEvent + for _, be := range nodes { + event := &workflows.BoundaryEvent{ + EventType: be.EventType, + TimerDelay: be.Delay, + } + event.ID = model.ID(generateWorkflowUUID()) + if len(be.Activities) > 0 { + event.Flow = &workflows.Flow{ + Activities: buildWorkflowActivities(be.Activities), + } + event.Flow.ID = model.ID(generateWorkflowUUID()) + } + events = append(events, event) + } + return events +} + +// buildWorkflowActivity converts a single AST activity node to an SDK workflow activity. +func buildWorkflowActivity(node ast.WorkflowActivityNode) workflows.WorkflowActivity { + switch n := node.(type) { + case *ast.WorkflowUserTaskNode: + return buildUserTask(n) + case *ast.WorkflowCallMicroflowNode: + return buildCallMicroflowTask(n) + case *ast.WorkflowCallWorkflowNode: + return buildCallWorkflowActivity(n) + case *ast.WorkflowDecisionNode: + return buildExclusiveSplit(n) + case *ast.WorkflowParallelSplitNode: + return buildParallelSplit(n) + case *ast.WorkflowJumpToNode: + return buildJumpTo(n) + case *ast.WorkflowWaitForTimerNode: + return buildWaitForTimer(n) + case *ast.WorkflowWaitForNotificationNode: + return buildWaitForNotification(n) + case *ast.WorkflowEndNode: + return buildEndWorkflow(n) + case *ast.WorkflowAnnotationActivityNode: + return buildAnnotationActivity(n) + default: + return nil + } +} + +func buildUserTask(n *ast.WorkflowUserTaskNode) *workflows.UserTask { + task := &workflows.UserTask{} + task.ID = model.ID(generateWorkflowUUID()) + task.Name = n.Name + task.Caption = n.Caption + task.DueDate = n.DueDate + task.TaskDescription = n.TaskDescription + task.IsMulti = n.IsMultiUser + + if n.Page.Module != "" { + task.Page = n.Page.Module + "." + n.Page.Name + } + + if n.Entity.Module != "" { + task.UserTaskEntity = n.Entity.Module + "." + n.Entity.Name + } + + // Targeting + switch n.Targeting.Kind { + case "microflow": + task.UserSource = &workflows.MicroflowBasedUserSource{ + Microflow: n.Targeting.Microflow.Module + "." + n.Targeting.Microflow.Name, + } + case "xpath": + task.UserSource = &workflows.XPathBasedUserSource{ + XPath: n.Targeting.XPath, + } + } + + // Outcomes + for _, outcomeNode := range n.Outcomes { + outcome := &workflows.UserTaskOutcome{ + Name: outcomeNode.Caption, + Caption: outcomeNode.Caption, + Value: outcomeNode.Caption, + } + outcome.ID = model.ID(generateWorkflowUUID()) + + if len(outcomeNode.Activities) > 0 { + outcome.Flow = &workflows.Flow{ + Activities: buildWorkflowActivities(outcomeNode.Activities), + } + outcome.Flow.ID = model.ID(generateWorkflowUUID()) + } + + task.Outcomes = append(task.Outcomes, outcome) + } + + // BoundaryEvents (Issue #7) + task.BoundaryEvents = buildBoundaryEvents(n.BoundaryEvents) + + return task +} + +func buildCallMicroflowTask(n *ast.WorkflowCallMicroflowNode) *workflows.CallMicroflowTask { + task := &workflows.CallMicroflowTask{} + task.ID = model.ID(generateWorkflowUUID()) + task.Name = n.Microflow.Name + task.Caption = n.Caption + task.Microflow = n.Microflow.Module + "." + n.Microflow.Name + + if task.Caption == "" { + task.Caption = task.Name + } + + for _, outcomeNode := range n.Outcomes { + outcome := buildConditionOutcome(outcomeNode) + if outcome != nil { + task.Outcomes = append(task.Outcomes, outcome) + } + } + + // Parameter mappings (Issue #10) + for _, pm := range n.ParameterMappings { + task.ParameterMappings = append(task.ParameterMappings, &workflows.ParameterMapping{ + Parameter: pm.Parameter, + Expression: pm.Expression, + }) + } + + // BoundaryEvents (Issue #7) + task.BoundaryEvents = buildBoundaryEvents(n.BoundaryEvents) + + return task +} + +func buildCallWorkflowActivity(n *ast.WorkflowCallWorkflowNode) *workflows.CallWorkflowActivity { + act := &workflows.CallWorkflowActivity{} + act.ID = model.ID(generateWorkflowUUID()) + act.Name = n.Workflow.Name + act.Caption = n.Caption + act.Workflow = n.Workflow.Module + "." + n.Workflow.Name + + if act.Caption == "" { + act.Caption = act.Name + } + + // Auto-bind $WorkflowContext parameter expression + act.ParameterExpression = "$WorkflowContext" + + // Explicit parameter mappings from MDL WITH clause + for _, pm := range n.ParameterMappings { + mapping := &workflows.ParameterMapping{ + Parameter: pm.Parameter, + Expression: pm.Expression, + } + mapping.BaseElement.ID = model.ID(mpr.GenerateID()) + act.ParameterMappings = append(act.ParameterMappings, mapping) + } + + return act +} + +func buildExclusiveSplit(n *ast.WorkflowDecisionNode) *workflows.ExclusiveSplitActivity { + act := &workflows.ExclusiveSplitActivity{} + act.ID = model.ID(generateWorkflowUUID()) + act.Expression = n.Expression + act.Caption = n.Caption + + if act.Caption == "" { + act.Caption = "Decision" + } + act.Name = act.Caption + + for _, outcomeNode := range n.Outcomes { + outcome := buildConditionOutcome(outcomeNode) + if outcome != nil { + act.Outcomes = append(act.Outcomes, outcome) + } + } + + return act +} + +func buildConditionOutcome(n ast.WorkflowConditionOutcomeNode) workflows.ConditionOutcome { + var subFlow *workflows.Flow + if len(n.Activities) > 0 { + subFlow = &workflows.Flow{ + Activities: buildWorkflowActivities(n.Activities), + } + subFlow.ID = model.ID(generateWorkflowUUID()) + } + + switch n.Value { + case "True": + o := &workflows.BooleanConditionOutcome{Value: true, Flow: subFlow} + o.ID = model.ID(generateWorkflowUUID()) + return o + case "False": + o := &workflows.BooleanConditionOutcome{Value: false, Flow: subFlow} + o.ID = model.ID(generateWorkflowUUID()) + return o + case "Default": + o := &workflows.VoidConditionOutcome{Flow: subFlow} + o.ID = model.ID(generateWorkflowUUID()) + return o + default: + // Enumeration value + o := &workflows.EnumerationValueConditionOutcome{Value: n.Value, Flow: subFlow} + o.ID = model.ID(generateWorkflowUUID()) + return o + } +} + +func buildParallelSplit(n *ast.WorkflowParallelSplitNode) *workflows.ParallelSplitActivity { + act := &workflows.ParallelSplitActivity{} + act.ID = model.ID(generateWorkflowUUID()) + act.Caption = n.Caption + if act.Caption == "" { + act.Caption = "Parallel split" + } + act.Name = act.Caption + + for _, pathNode := range n.Paths { + outcome := &workflows.ParallelSplitOutcome{} + outcome.ID = model.ID(generateWorkflowUUID()) + if len(pathNode.Activities) > 0 { + outcome.Flow = &workflows.Flow{ + Activities: buildWorkflowActivities(pathNode.Activities), + } + outcome.Flow.ID = model.ID(generateWorkflowUUID()) + } + act.Outcomes = append(act.Outcomes, outcome) + } + + return act +} + +func buildJumpTo(n *ast.WorkflowJumpToNode) *workflows.JumpToActivity { + act := &workflows.JumpToActivity{} + act.ID = model.ID(generateWorkflowUUID()) + act.Name = n.Target + act.Caption = n.Caption + act.TargetActivity = n.Target + + if act.Caption == "" { + act.Caption = act.Name + } + + return act +} + +func buildWaitForTimer(n *ast.WorkflowWaitForTimerNode) *workflows.WaitForTimerActivity { + act := &workflows.WaitForTimerActivity{} + act.ID = model.ID(generateWorkflowUUID()) + act.DelayExpression = n.DelayExpression + act.Caption = n.Caption + + if act.Caption == "" { + act.Caption = "Wait for timer" + } + act.Name = act.Caption + + return act +} + +func buildWaitForNotification(n *ast.WorkflowWaitForNotificationNode) *workflows.WaitForNotificationActivity { + act := &workflows.WaitForNotificationActivity{} + act.ID = model.ID(generateWorkflowUUID()) + act.Caption = n.Caption + + if act.Caption == "" { + act.Caption = "Wait for notification" + } + act.Name = act.Caption + + // BoundaryEvents (Issue #7) + act.BoundaryEvents = buildBoundaryEvents(n.BoundaryEvents) + + return act +} + +func buildEndWorkflow(n *ast.WorkflowEndNode) *workflows.EndWorkflowActivity { + act := &workflows.EndWorkflowActivity{} + act.ID = model.ID(generateWorkflowUUID()) + act.Caption = n.Caption + + if act.Caption == "" { + act.Caption = "End" + } + act.Name = act.Caption + + return act +} + +// deduplicateActivityNames ensures all activity names within a workflow are unique. +// Mendix Studio Pro requires unique activity names (CE0495). +func deduplicateActivityNames(activities []workflows.WorkflowActivity) { + nameCount := make(map[string]int) + deduplicateActivityNamesInFlow(activities, nameCount) +} + +// deduplicateActivityNamesInFlow recursively deduplicates activity names. +func deduplicateActivityNamesInFlow(activities []workflows.WorkflowActivity, nameCount map[string]int) { + for _, act := range activities { + switch a := act.(type) { + case *workflows.UserTask: + a.Name = uniqueName(a.Name, nameCount) + for _, outcome := range a.Outcomes { + if outcome.Flow != nil { + deduplicateActivityNamesInFlow(outcome.Flow.Activities, nameCount) + } + } + case *workflows.CallMicroflowTask: + a.Name = uniqueName(a.Name, nameCount) + for _, outcome := range a.Outcomes { + switch o := outcome.(type) { + case *workflows.BooleanConditionOutcome: + if o.Flow != nil { + deduplicateActivityNamesInFlow(o.Flow.Activities, nameCount) + } + case *workflows.EnumerationValueConditionOutcome: + if o.Flow != nil { + deduplicateActivityNamesInFlow(o.Flow.Activities, nameCount) + } + case *workflows.VoidConditionOutcome: + if o.Flow != nil { + deduplicateActivityNamesInFlow(o.Flow.Activities, nameCount) + } + } + } + case *workflows.CallWorkflowActivity: + a.Name = uniqueName(a.Name, nameCount) + case *workflows.ExclusiveSplitActivity: + a.Name = uniqueName(a.Name, nameCount) + for _, outcome := range a.Outcomes { + switch o := outcome.(type) { + case *workflows.BooleanConditionOutcome: + if o.Flow != nil { + deduplicateActivityNamesInFlow(o.Flow.Activities, nameCount) + } + case *workflows.EnumerationValueConditionOutcome: + if o.Flow != nil { + deduplicateActivityNamesInFlow(o.Flow.Activities, nameCount) + } + case *workflows.VoidConditionOutcome: + if o.Flow != nil { + deduplicateActivityNamesInFlow(o.Flow.Activities, nameCount) + } + } + } + case *workflows.ParallelSplitActivity: + a.Name = uniqueName(a.Name, nameCount) + for _, outcome := range a.Outcomes { + if outcome.Flow != nil { + deduplicateActivityNamesInFlow(outcome.Flow.Activities, nameCount) + } + } + case *workflows.JumpToActivity: + a.Name = uniqueName(a.Name, nameCount) + case *workflows.WaitForTimerActivity: + a.Name = uniqueName(a.Name, nameCount) + case *workflows.WaitForNotificationActivity: + a.Name = uniqueName(a.Name, nameCount) + case *workflows.EndWorkflowActivity: + a.Name = uniqueName(a.Name, nameCount) + } + } +} + +// uniqueName returns a unique name by appending a number if the name was seen before. +func uniqueName(name string, nameCount map[string]int) string { + nameCount[name]++ + count := nameCount[name] + if count == 1 { + return name + } + return fmt.Sprintf("%s%d", name, count) +} + +func buildAnnotationActivity(n *ast.WorkflowAnnotationActivityNode) *workflows.WorkflowAnnotationActivity { + a := &workflows.WorkflowAnnotationActivity{} + a.ID = model.ID(mpr.GenerateID()) + a.Description = n.Text + return a +} + +// sanitizeActivityName converts a display caption to a valid Mendix identifier. +// Mendix names must start with a letter/underscore and contain only letters, digits, underscores. +func sanitizeActivityName(name string) string { + var b strings.Builder + for i, r := range name { + if unicode.IsLetter(r) || r == '_' { + b.WriteRune(r) + } else if unicode.IsDigit(r) && i > 0 { + b.WriteRune(r) + } else if r == ' ' || r == '-' { + b.WriteRune('_') + } + } + result := b.String() + if result == "" { + return "activity" + } + return result +} + +// autoBindWorkflowParameters resolves microflow/workflow parameters and generates +// ParameterMappings, default outcomes, and sanitized names for workflow activities. +func (e *Executor) autoBindWorkflowParameters(activities []workflows.WorkflowActivity) { + e.autoBindActivitiesInFlow(activities) +} + +func (e *Executor) autoBindActivitiesInFlow(activities []workflows.WorkflowActivity) { + for _, act := range activities { + switch a := act.(type) { + case *workflows.CallMicroflowTask: + e.autoBindCallMicroflow(a) + // Recurse into outcomes + for _, outcome := range a.Outcomes { + switch o := outcome.(type) { + case *workflows.BooleanConditionOutcome: + if o.Flow != nil { + e.autoBindActivitiesInFlow(o.Flow.Activities) + } + case *workflows.VoidConditionOutcome: + if o.Flow != nil { + e.autoBindActivitiesInFlow(o.Flow.Activities) + } + } + } + case *workflows.CallWorkflowActivity: + e.autoBindCallWorkflow(a) + case *workflows.UserTask: + // Sanitize name + a.Name = sanitizeActivityName(a.Name) + for _, outcome := range a.Outcomes { + if outcome.Flow != nil { + e.autoBindActivitiesInFlow(outcome.Flow.Activities) + } + } + case *workflows.ParallelSplitActivity: + // Sanitize name (spaces not allowed) + a.Name = sanitizeActivityName(a.Name) + for _, outcome := range a.Outcomes { + if outcome.Flow != nil { + e.autoBindActivitiesInFlow(outcome.Flow.Activities) + } + } + case *workflows.ExclusiveSplitActivity: + a.Name = sanitizeActivityName(a.Name) + for _, outcome := range a.Outcomes { + switch o := outcome.(type) { + case *workflows.BooleanConditionOutcome: + if o.Flow != nil { + e.autoBindActivitiesInFlow(o.Flow.Activities) + } + case *workflows.VoidConditionOutcome: + if o.Flow != nil { + e.autoBindActivitiesInFlow(o.Flow.Activities) + } + } + } + case *workflows.WaitForNotificationActivity: + a.Name = sanitizeActivityName(a.Name) + case *workflows.WaitForTimerActivity: + a.Name = sanitizeActivityName(a.Name) + case *workflows.JumpToActivity: + a.Name = sanitizeActivityName(a.Name) + } + } +} + +// autoBindCallMicroflow resolves microflow parameters and auto-generates ParameterMappings. +func (e *Executor) autoBindCallMicroflow(task *workflows.CallMicroflowTask) { + // Sanitize name + task.Name = sanitizeActivityName(task.Name) + + // Skip if already has parameter mappings + if len(task.ParameterMappings) > 0 { + return + } + + // Look up the microflow to get its parameters + mfs, err := e.reader.ListMicroflows() + if err != nil { + return + } + + h, err := e.getHierarchy() + if err != nil { + return + } + + for _, mf := range mfs { + modID := h.FindModuleID(mf.ContainerID) + modName := h.GetModuleName(modID) + qualifiedName := modName + "." + mf.Name + if qualifiedName != task.Microflow { + continue + } + + // Found the microflow — bind parameters + for _, param := range mf.Parameters { + paramQualifiedName := qualifiedName + "." + param.Name + mapping := &workflows.ParameterMapping{ + Parameter: paramQualifiedName, + Expression: "$WorkflowContext", + } + mapping.BaseElement.ID = model.ID(mpr.GenerateID()) + task.ParameterMappings = append(task.ParameterMappings, mapping) + } + + // Auto-generate Default outcome if no outcomes specified + if len(task.Outcomes) == 0 { + outcome := &workflows.VoidConditionOutcome{ + Flow: &workflows.Flow{}, + } + outcome.BaseElement.ID = model.ID(mpr.GenerateID()) + outcome.Flow.BaseElement.ID = model.ID(mpr.GenerateID()) + task.Outcomes = append(task.Outcomes, outcome) + } + break + } +} + +// autoBindCallWorkflow resolves workflow parameters and generates ParameterMappings. +func (e *Executor) autoBindCallWorkflow(act *workflows.CallWorkflowActivity) { + // Sanitize name + act.Name = sanitizeActivityName(act.Name) + + // Skip if already has parameter mappings (explicit from MDL WITH clause) + if len(act.ParameterMappings) > 0 { + return + } + + // Look up the target workflow to check its parameter + wfs, err := e.reader.ListWorkflows() + if err != nil { + return + } + + h, err := e.getHierarchy() + if err != nil { + return + } + + for _, wf := range wfs { + modID := h.FindModuleID(wf.ContainerID) + modName := h.GetModuleName(modID) + qualifiedName := modName + "." + wf.Name + if qualifiedName != act.Workflow { + continue + } + + // If the target workflow has a parameter, generate ParameterMappings + if wf.Parameter != nil && wf.Parameter.EntityRef != "" { + act.ParameterExpression = "$WorkflowContext" + // Generate WorkflowCallParameterMapping: Parameter = Workflow.ParamName + paramName := qualifiedName + ".WorkflowContext" + mapping := &workflows.ParameterMapping{ + Parameter: paramName, + Expression: "$WorkflowContext", + } + mapping.BaseElement.ID = model.ID(mpr.GenerateID()) + act.ParameterMappings = append(act.ParameterMappings, mapping) + } + break + } +} diff --git a/mdl/executor/executor.go b/mdl/executor/executor.go index e2df03f..503971e 100644 --- a/mdl/executor/executor.go +++ b/mdl/executor/executor.go @@ -60,11 +60,20 @@ type createdSnippetInfo struct { ContainerID model.ID } +const ( + // maxOutputLines is the per-statement line limit. Statements that produce more + // lines than this are aborted to prevent runaway output from infinite loops. + maxOutputLines = 10_000 + // executeTimeout is the maximum wall-clock time allowed for a single statement. + executeTimeout = 5 * time.Minute +) + // Executor executes MDL statements against a Mendix project. type Executor struct { writer *mpr.Writer reader *mpr.Reader output io.Writer + guard *outputGuard // line-limit wrapper around output mprPath string settings map[string]any cache *executorCache @@ -77,8 +86,10 @@ type Executor struct { // New creates a new executor with the given output writer. func New(output io.Writer) *Executor { + guard := newOutputGuard(output, maxOutputLines) return &Executor{ - output: output, + output: guard, + guard: guard, settings: make(map[string]any), } } @@ -93,10 +104,33 @@ func (e *Executor) SetLogger(l *diaglog.Logger) { e.logger = l } -// Execute runs a single MDL statement, logging execution time and errors. +// Execute runs a single MDL statement with output-line and wall-clock guards. +// Each statement gets a fresh line budget. If the statement exceeds maxOutputLines +// lines of output or runs longer than executeTimeout, it is aborted with an error. func (e *Executor) Execute(stmt ast.Statement) error { start := time.Now() - err := e.executeInner(stmt) + + // Reset per-statement line counter. + if e.guard != nil { + e.guard.reset() + } + + // Run statement in a goroutine so we can enforce a wall-clock timeout. + // The outputGuard handles race-safe writes if the goroutine outlives the timeout. + type result struct{ err error } + ch := make(chan result, 1) + go func() { + ch <- result{e.executeInner(stmt)} + }() + + var err error + select { + case r := <-ch: + err = r.err + case <-time.After(executeTimeout): + err = fmt.Errorf("statement timed out after %v", executeTimeout) + } + if e.logger != nil { e.logger.Command(stmtTypeName(stmt), stmtSummary(stmt), time.Since(start), err) } @@ -201,6 +235,10 @@ func (e *Executor) executeInner(stmt ast.Statement) error { return e.execGrantPageAccess(s) case *ast.RevokePageAccessStmt: return e.execRevokePageAccess(s) + case *ast.GrantWorkflowAccessStmt: + return e.execGrantWorkflowAccess(s) + case *ast.RevokeWorkflowAccessStmt: + return e.execRevokeWorkflowAccess(s) case *ast.AlterProjectSecurityStmt: return e.execAlterProjectSecurity(s) case *ast.CreateDemoUserStmt: @@ -214,6 +252,12 @@ func (e *Executor) executeInner(stmt ast.Statement) error { case *ast.AlterNavigationStmt: return e.execAlterNavigation(s) + // Workflow statements + case *ast.CreateWorkflowStmt: + return e.execCreateWorkflow(s) + case *ast.DropWorkflowStmt: + return e.execDropWorkflow(s) + // Business Event statements case *ast.CreateBusinessEventServiceStmt: return e.createBusinessEventService(s) @@ -652,6 +696,8 @@ func (e *Executor) execShow(s *ast.ShowStmt) error { return e.showAccessOnMicroflow(s.Name) case ast.ShowAccessOnPage: return e.showAccessOnPage(s.Name) + case ast.ShowAccessOnWorkflow: + return e.showAccessOnWorkflow(s.Name) case ast.ShowSecurityMatrix: return e.showSecurityMatrix(s.InModule) case ast.ShowODataClients: diff --git a/mdl/executor/helpers.go b/mdl/executor/helpers.go index 984a57c..24cf0a2 100644 --- a/mdl/executor/helpers.go +++ b/mdl/executor/helpers.go @@ -499,7 +499,7 @@ func getAttributeTypeName(at domainmodel.AttributeType) string { if t.Length > 0 { return fmt.Sprintf("String(%d)", t.Length) } - return "String" + return "String(unlimited)" case *domainmodel.IntegerAttributeType: return "Integer" case *domainmodel.LongAttributeType: diff --git a/mdl/executor/output_guard.go b/mdl/executor/output_guard.go new file mode 100644 index 0000000..d05e0d8 --- /dev/null +++ b/mdl/executor/output_guard.go @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: Apache-2.0 + +package executor + +import ( + "bytes" + "fmt" + "io" + "sync" +) + +// outputGuard wraps an io.Writer with a per-statement line limit. +// It is thread-safe and resettable, allowing reuse across statements. +// When the line limit is exceeded, Write returns an error and all subsequent +// writes are suppressed, preventing runaway output from infinite loops. +type outputGuard struct { + mu sync.Mutex + w io.Writer + maxLines int + lines int + exceeded bool +} + +func newOutputGuard(w io.Writer, maxLines int) *outputGuard { + return &outputGuard{w: w, maxLines: maxLines} +} + +// reset clears the line count for the next statement. +func (g *outputGuard) reset() { + g.mu.Lock() + g.lines = 0 + g.exceeded = false + g.mu.Unlock() +} + +// Write implements io.Writer. Returns an error once the line limit is exceeded. +func (g *outputGuard) Write(p []byte) (int, error) { + g.mu.Lock() + defer g.mu.Unlock() + + if g.exceeded { + return len(p), nil // silently discard; caller already got the error + } + + g.lines += bytes.Count(p, []byte{'\n'}) + if g.lines > g.maxLines { + g.exceeded = true + // Write the current chunk first so output isn't abruptly cut mid-line. + _, _ = g.w.Write(p) + return len(p), fmt.Errorf("output line limit exceeded (%d lines); statement aborted", g.maxLines) + } + + return g.w.Write(p) +} diff --git a/mdl/executor/roundtrip_workflow_test.go b/mdl/executor/roundtrip_workflow_test.go new file mode 100644 index 0000000..1941adb --- /dev/null +++ b/mdl/executor/roundtrip_workflow_test.go @@ -0,0 +1,382 @@ +// SPDX-License-Identifier: Apache-2.0 + +//go:build integration + +package executor + +import ( + "strings" + "testing" +) + +// TestRoundtripWorkflow_Comprehensive tests all workflow MDL syntax in a single roundtrip. +// +// Activity types covered: +// - ANNOTATION +// - USER TASK (PAGE, TARGETING MICROFLOW, DUE DATE, OUTCOMES with nested, BOUNDARY EVENT x2) +// - MULTI USER TASK (PAGE, TARGETING MICROFLOW, OUTCOMES) +// - CALL MICROFLOW (WITH params, OUTCOMES TRUE/FALSE) +// - DECISION (expression, OUTCOMES TRUE/FALSE with nested JUMP TO and WAIT FOR TIMER) +// - PARALLEL SPLIT (PATH 1 with USER TASK, PATH 2 with CALL WORKFLOW) +// - WAIT FOR TIMER (with ISO 8601 delay) +// - WAIT FOR NOTIFICATION (with BOUNDARY EVENT NON INTERRUPTING TIMER) +// - JUMP TO (inside DECISION outcome) +// - CALL WORKFLOW (sub-workflow with parameter expression) +func TestRoundtripWorkflow_Comprehensive(t *testing.T) { + env := setupTestEnv(t) + defer env.teardown() + + mod := testModule + + // --- Prerequisites --- + + // Context entity for both workflows + if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY ` + mod + `.WfCtxEntity ( + Score: Integer, + IsApproved: Boolean DEFAULT false + );`); err != nil { + t.Fatalf("create WfCtxEntity: %v", err) + } + + // Microflow: single-user targeting + if err := env.executeMDL(`CREATE MICROFLOW ` + mod + `.GetSingleReviewer () RETURNS String BEGIN END;`); err != nil { + t.Fatalf("create GetSingleReviewer: %v", err) + } + + // Microflow: multi-user targeting + if err := env.executeMDL(`CREATE MICROFLOW ` + mod + `.GetMultiReviewers () RETURNS String BEGIN END;`); err != nil { + t.Fatalf("create GetMultiReviewers: %v", err) + } + + // Microflow: called by CALL MICROFLOW (returns Boolean) + if err := env.executeMDL(`CREATE MICROFLOW ` + mod + `.ScoreCalc (Score: Integer) RETURNS Boolean BEGIN END;`); err != nil { + t.Fatalf("create ScoreCalc: %v", err) + } + + // Sub-workflow for CALL WORKFLOW + if err := env.executeMDL(`CREATE WORKFLOW ` + mod + `.SubApprovalFlow + PARAMETER $WorkflowContext: ` + mod + `.WfCtxEntity +BEGIN + USER TASK SubTask 'Sub-Approval' + PAGE ` + mod + `.SubPage + OUTCOMES 'Done' { }; +END WORKFLOW;`); err != nil { + t.Fatalf("create SubApprovalFlow: %v", err) + } + + // --- Main comprehensive workflow --- + createMDL := `CREATE WORKFLOW ` + mod + `.ComprehensiveFlow + PARAMETER $WorkflowContext: ` + mod + `.WfCtxEntity +BEGIN + + ANNOTATION 'Comprehensive workflow covering all MDL syntax'; + + USER TASK ReviewTask 'Review Request' + PAGE ` + mod + `.ReviewPage + TARGETING MICROFLOW ` + mod + `.GetSingleReviewer + OUTCOMES + 'Approve' { } + 'Reject' { } + BOUNDARY EVENT INTERRUPTING TIMER '${PT24H}' NON INTERRUPTING TIMER '${PT1H}'; + + MULTI USER TASK MultiReviewTask 'Multi-Person Review' + PAGE ` + mod + `.MultiReviewPage + TARGETING MICROFLOW ` + mod + `.GetMultiReviewers + OUTCOMES 'Complete' { }; + + CALL MICROFLOW ` + mod + `.ScoreCalc + WITH (Score = '$WorkflowContext/Score') + OUTCOMES + TRUE -> { } + FALSE -> { }; + + DECISION '$WorkflowContext/IsApproved' + OUTCOMES + TRUE -> { + WAIT FOR TIMER '${PT2H}'; + } + FALSE -> { + JUMP TO ReviewTask; + }; + + PARALLEL SPLIT + PATH 1 { + USER TASK FinalApprove 'Final Approval' + PAGE ` + mod + `.ApprovePage + OUTCOMES 'Approved' { }; + } + PATH 2 { + CALL WORKFLOW ` + mod + `.SubApprovalFlow; + }; + + WAIT FOR NOTIFICATION; + + ANNOTATION 'End of flow'; + +END WORKFLOW;` + + if err := env.executeMDL(createMDL); err != nil { + t.Fatalf("create ComprehensiveFlow: %v", err) + } + + output, err := env.describeMDL(`DESCRIBE WORKFLOW ` + mod + `.ComprehensiveFlow;`) + if err != nil { + t.Fatalf("describe ComprehensiveFlow: %v", err) + } + + t.Logf("DESCRIBE output:\n%s", output) + + checks := []struct { + label string + keyword string + }{ + {"annotation activity", "ANNOTATION 'Comprehensive workflow"}, + {"user task", "USER TASK ReviewTask"}, + {"outcome approve", "'Approve'"}, + {"outcome reject", "'Reject'"}, + {"boundary interrupting", "BOUNDARY EVENT INTERRUPTING TIMER '${PT24H}'"}, + {"boundary non interrupting", "BOUNDARY EVENT NON INTERRUPTING TIMER '${PT1H}'"}, + {"multi user task", "MULTI USER TASK MultiReviewTask"}, + {"call microflow with", "CALL MICROFLOW " + mod + ".ScoreCalc WITH (Score ="}, + {"outcomes true", "TRUE ->"}, + {"outcomes false", "FALSE ->"}, + {"decision", "DECISION '$WorkflowContext/IsApproved'"}, + {"wait for timer", "WAIT FOR TIMER '${PT2H}'"}, + {"jump to", "JUMP TO ReviewTask"}, + {"parallel split", "PARALLEL SPLIT"}, + {"path 1", "PATH 1"}, + {"path 2", "PATH 2"}, + {"call workflow", "CALL WORKFLOW " + mod + ".SubApprovalFlow"}, + {"wait for notification", "WAIT FOR NOTIFICATION"}, + {"trailing annotation", "ANNOTATION 'End of flow'"}, + {"parameter", "PARAMETER $WorkflowContext: " + mod + ".WfCtxEntity"}, + } + + var failed []string + for _, c := range checks { + if !strings.Contains(output, c.keyword) { + failed = append(failed, c.label+": "+c.keyword) + } + } + if len(failed) > 0 { + t.Errorf("DESCRIBE output missing %d expected keywords:\n %s\n\nFull output:\n%s", + len(failed), strings.Join(failed, "\n "), output) + } +} + +func TestRoundtripWorkflow_BoundaryEventInterrupting(t *testing.T) { + env := setupTestEnv(t) + defer env.teardown() + + createMDL := `CREATE WORKFLOW ` + testModule + `.WfBoundaryInt + PARAMETER $WorkflowContext: ` + testModule + `.TestEntitySimple +BEGIN + USER TASK act1 'Review' + PAGE ` + testModule + `.ReviewPage + OUTCOMES 'Approve' { } + BOUNDARY EVENT INTERRUPTING TIMER '${PT1H}' + ; +END WORKFLOW;` + + if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY ` + testModule + `.TestEntitySimple (Name: String(100));`); err != nil { + t.Fatalf("Failed to create entity: %v", err) + } + + if err := env.executeMDL(createMDL); err != nil { + t.Fatalf("Failed to create workflow: %v", err) + } + + output, err := env.describeMDL(`DESCRIBE WORKFLOW ` + testModule + `.WfBoundaryInt;`) + if err != nil { + t.Fatalf("Failed to describe workflow: %v", err) + } + + if !strings.Contains(output, "BOUNDARY EVENT INTERRUPTING TIMER") { + t.Errorf("Expected DESCRIBE output to contain 'BOUNDARY EVENT INTERRUPTING TIMER', got:\n%s", output) + } +} + +func TestRoundtripWorkflow_BoundaryEventNonInterrupting(t *testing.T) { + env := setupTestEnv(t) + defer env.teardown() + + createMDL := `CREATE WORKFLOW ` + testModule + `.WfBoundaryNonInt + PARAMETER $WorkflowContext: ` + testModule + `.TestEntitySimple2 +BEGIN + USER TASK act1 'Review' + PAGE ` + testModule + `.ReviewPage + OUTCOMES 'Approve' { } + BOUNDARY EVENT NON INTERRUPTING TIMER '${PT2H}' + ; +END WORKFLOW;` + + if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY ` + testModule + `.TestEntitySimple2 (Name: String(100));`); err != nil { + t.Fatalf("Failed to create entity: %v", err) + } + + if err := env.executeMDL(createMDL); err != nil { + t.Fatalf("Failed to create workflow: %v", err) + } + + output, err := env.describeMDL(`DESCRIBE WORKFLOW ` + testModule + `.WfBoundaryNonInt;`) + if err != nil { + t.Fatalf("Failed to describe workflow: %v", err) + } + + if !strings.Contains(output, "BOUNDARY EVENT NON INTERRUPTING TIMER") { + t.Errorf("Expected DESCRIBE output to contain 'BOUNDARY EVENT NON INTERRUPTING TIMER', got:\n%s", output) + } +} + +func TestRoundtripWorkflow_MultiUserTask(t *testing.T) { + env := setupTestEnv(t) + defer env.teardown() + + createMDL := `CREATE WORKFLOW ` + testModule + `.WfMultiUser + PARAMETER $WorkflowContext: ` + testModule + `.TestEntityMulti +BEGIN + MULTI USER TASK act1 'Caption' + PAGE ` + testModule + `.ReviewPage + OUTCOMES 'Approve' { } + ; +END WORKFLOW;` + + if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY ` + testModule + `.TestEntityMulti (Name: String(100));`); err != nil { + t.Fatalf("Failed to create entity: %v", err) + } + + if err := env.executeMDL(createMDL); err != nil { + t.Fatalf("Failed to create workflow: %v", err) + } + + output, err := env.describeMDL(`DESCRIBE WORKFLOW ` + testModule + `.WfMultiUser;`) + if err != nil { + t.Fatalf("Failed to describe workflow: %v", err) + } + + if !strings.Contains(output, "MULTI USER TASK") { + t.Errorf("Expected DESCRIBE output to contain 'MULTI USER TASK', got:\n%s", output) + } +} + +func TestRoundtripWorkflow_AnnotationActivity(t *testing.T) { + env := setupTestEnv(t) + defer env.teardown() + + createMDL := `CREATE WORKFLOW ` + testModule + `.WfAnnotation + PARAMETER $WorkflowContext: ` + testModule + `.TestEntityAnnot +BEGIN + ANNOTATION 'This is a workflow note'; +END WORKFLOW;` + + if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY ` + testModule + `.TestEntityAnnot (Name: String(100));`); err != nil { + t.Fatalf("Failed to create entity: %v", err) + } + + if err := env.executeMDL(createMDL); err != nil { + t.Fatalf("Failed to create workflow: %v", err) + } + + output, err := env.describeMDL(`DESCRIBE WORKFLOW ` + testModule + `.WfAnnotation;`) + if err != nil { + t.Fatalf("Failed to describe workflow: %v", err) + } + + if !strings.Contains(output, "ANNOTATION 'This is a workflow note'") { + t.Errorf("Expected DESCRIBE output to contain \"ANNOTATION 'This is a workflow note'\", got:\n%s", output) + } + + // Full round-trip: DESCRIBE output must be re-executable (annotation must survive re-create) + describeOutput := output + // Replace WORKFLOW with CREATE OR REPLACE WORKFLOW for round-trip execution + createFromDescribe := strings.Replace(describeOutput, "\nWORKFLOW ", "\nCREATE OR REPLACE WORKFLOW ", 1) + // Strip comment header lines (-- ...) before the CREATE OR REPLACE WORKFLOW + var mdlLines []string + inBody := false + for _, line := range strings.Split(createFromDescribe, "\n") { + if strings.HasPrefix(strings.TrimSpace(line), "CREATE OR REPLACE WORKFLOW") { + inBody = true + } + if inBody { + mdlLines = append(mdlLines, line) + } + } + roundTripMDL := strings.Join(mdlLines, "\n") + if err := env.executeMDL(roundTripMDL); err != nil { + t.Errorf("Round-trip execution failed (DESCRIBE output is not re-executable): %v\nMDL:\n%s", err, roundTripMDL) + } +} + +// TestRoundtripWorkflow_AnnotationBeforeActivity tests that a workflow activity's +// embedded annotation (BaseWorkflowActivity.Annotation) is preserved in DESCRIBE output +// as a parseable ANNOTATION statement rather than a SQL comment. +func TestRoundtripWorkflow_AnnotationBeforeActivity(t *testing.T) { + env := setupTestEnv(t) + defer env.teardown() + + // Create a workflow with an ANNOTATION before a WAIT FOR TIMER. + // This mimics the pattern from Studio Pro where an annotation is attached to an activity. + createMDL := `CREATE WORKFLOW ` + testModule + `.WfAnnotBeforeTimer + PARAMETER $WorkflowContext: ` + testModule + `.TestEntityAnnotTimer +BEGIN + ANNOTATION 'I am a note'; + WAIT FOR TIMER 'addDays([%CurrentDateTime%], 1)' COMMENT 'Timer'; +END WORKFLOW;` + + if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY ` + testModule + `.TestEntityAnnotTimer (Name: String(100));`); err != nil { + t.Fatalf("Failed to create entity: %v", err) + } + + if err := env.executeMDL(createMDL); err != nil { + t.Fatalf("Failed to create workflow: %v", err) + } + + output, err := env.describeMDL(`DESCRIBE WORKFLOW ` + testModule + `.WfAnnotBeforeTimer;`) + if err != nil { + t.Fatalf("Failed to describe workflow: %v", err) + } + + // The annotation must appear as a parseable ANNOTATION statement, not as a SQL comment. + if !strings.Contains(output, "ANNOTATION 'I am a note'") { + t.Errorf("Expected DESCRIBE to emit ANNOTATION statement, got:\n%s", output) + } + if strings.Contains(output, "-- I am a note") { + t.Errorf("DESCRIBE must not emit annotation as SQL comment (not round-trippable), got:\n%s", output) + } + if !strings.Contains(output, "WAIT FOR TIMER") { + t.Errorf("Expected DESCRIBE to contain WAIT FOR TIMER, got:\n%s", output) + } +} + +func TestRoundtripWorkflow_CallMicroflowWithParams(t *testing.T) { + env := setupTestEnv(t) + defer env.teardown() + + createMDL := `CREATE WORKFLOW ` + testModule + `.WfCallMf + PARAMETER $WorkflowContext: ` + testModule + `.TestEntityCallMf +BEGIN + CALL MICROFLOW ` + testModule + `.SomeMicroflow WITH (Amount = '$WorkflowContext/Amount') + OUTCOMES TRUE -> { } FALSE -> { }; +END WORKFLOW;` + + if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY ` + testModule + `.TestEntityCallMf (Amount: Decimal);`); err != nil { + t.Fatalf("Failed to create entity: %v", err) + } + + if err := env.executeMDL(`CREATE MICROFLOW ` + testModule + `.SomeMicroflow (Amount: Decimal) RETURNS Boolean BEGIN END;`); err != nil { + t.Fatalf("Failed to create microflow: %v", err) + } + + if err := env.executeMDL(createMDL); err != nil { + t.Fatalf("Failed to create workflow: %v", err) + } + + output, err := env.describeMDL(`DESCRIBE WORKFLOW ` + testModule + `.WfCallMf;`) + if err != nil { + t.Fatalf("Failed to describe workflow: %v", err) + } + + if !strings.Contains(output, "WITH (") { + t.Errorf("Expected DESCRIBE output to contain 'WITH (', got:\n%s", output) + } +} diff --git a/mdl/executor/stmt_summary.go b/mdl/executor/stmt_summary.go index 337f23f..f562b10 100644 --- a/mdl/executor/stmt_summary.go +++ b/mdl/executor/stmt_summary.go @@ -101,6 +101,10 @@ func stmtSummary(stmt ast.Statement) string { return fmt.Sprintf("GRANT VIEW ON PAGE %s", s.Page) case *ast.RevokePageAccessStmt: return fmt.Sprintf("REVOKE VIEW ON PAGE %s", s.Page) + case *ast.GrantWorkflowAccessStmt: + return fmt.Sprintf("GRANT EXECUTE ON WORKFLOW %s", s.Workflow) + case *ast.RevokeWorkflowAccessStmt: + return fmt.Sprintf("REVOKE EXECUTE ON WORKFLOW %s", s.Workflow) case *ast.GrantEntityAccessStmt: return fmt.Sprintf("GRANT ON ENTITY %s", s.Entity) case *ast.RevokeEntityAccessStmt: diff --git a/mdl/grammar/MDLLexer.g4 b/mdl/grammar/MDLLexer.g4 index 886d56a..f055d07 100644 --- a/mdl/grammar/MDLLexer.g4 +++ b/mdl/grammar/MDLLexer.g4 @@ -415,6 +415,7 @@ PATTERN: P A T T E R N; EXPRESSION: E X P R E S S I O N; XPATH: X P A T H; CONSTRAINT: C O N S T R A I N T; +CALCULATED: C A L C U L A T E D; // ============================================================================= // REST CLIENT KEYWORDS @@ -580,9 +581,29 @@ APPLY: A P P L Y; ACCESS: A C C E S S; LEVEL: L E V E L; USER: U S E R; +TASK: T A S K; +DECISION: D E C I S I O N; +SPLIT: S P L I T; +OUTCOMES: O U T C O M E S; +TARGETING: T A R G E T I N G; +NOTIFICATION: N O T I F I C A T I O N; +TIMER: T I M E R; +JUMP: J U M P; +DUE: D U E; +OVERVIEW: O V E R V I E W; +DATE: D A T E; +PARALLEL: P A R A L L E L; +WAIT: W A I T; +ANNOTATION: A N N O T A T I O N; +BOUNDARY: B O U N D A R Y; +INTERRUPTING: I N T E R R U P T I N G; +NON: N O N; +MULTI: M U L T I; +BY: B Y; READ: R E A D; WRITE: W R I T E; DESCRIPTION: D E S C R I P T I O N; +DISPLAY: D I S P L A Y; OFF: O F F; USERS: U S E R S; diff --git a/mdl/grammar/MDLParser.g4 b/mdl/grammar/MDLParser.g4 index 8c4d114..89f4658 100644 --- a/mdl/grammar/MDLParser.g4 +++ b/mdl/grammar/MDLParser.g4 @@ -94,6 +94,7 @@ createStatement | createExternalEntityStatement | createNavigationStatement | createBusinessEventServiceStatement + | createWorkflowStatement ) ; @@ -234,6 +235,7 @@ dropStatement | DROP ODATA CLIENT qualifiedName | DROP ODATA SERVICE qualifiedName | DROP BUSINESS EVENT SERVICE qualifiedName + | DROP WORKFLOW qualifiedName ; renameStatement @@ -291,6 +293,8 @@ securityStatement | revokeMicroflowAccessStatement | grantPageAccessStatement | revokePageAccessStatement + | grantWorkflowAccessStatement + | revokeWorkflowAccessStatement | grantODataServiceAccessStatement | revokeODataServiceAccessStatement | alterProjectSecurityStatement @@ -348,6 +352,14 @@ revokePageAccessStatement : REVOKE VIEW ON PAGE qualifiedName FROM moduleRoleList ; +grantWorkflowAccessStatement + : GRANT EXECUTE ON WORKFLOW qualifiedName TO moduleRoleList + ; + +revokeWorkflowAccessStatement + : REVOKE EXECUTE ON WORKFLOW qualifiedName FROM moduleRoleList + ; + grantODataServiceAccessStatement : GRANT ACCESS ON ODATA SERVICE qualifiedName TO moduleRoleList ; @@ -362,7 +374,7 @@ alterProjectSecurityStatement ; createDemoUserStatement - : CREATE DEMO USER STRING_LITERAL PASSWORD STRING_LITERAL + : CREATE DEMO USER STRING_LITERAL PASSWORD STRING_LITERAL (ENTITY qualifiedName)? LPAREN identifierOrKeyword (COMMA identifierOrKeyword)* RPAREN ; @@ -527,6 +539,7 @@ attributeConstraint | UNIQUE (ERROR STRING_LITERAL)? | DEFAULT (literal | expression) | REQUIRED (ERROR STRING_LITERAL)? + | CALCULATED (BY? qualifiedName)? ; /** @@ -2173,6 +2186,139 @@ businessEventAttrDef : IDENTIFIER COLON dataType ; +// ============================================================================= +// CREATE WORKFLOW +// ============================================================================= + +/** + * Create a workflow with activities. + * + * @example Simple workflow with user task + * ```mdl + * CREATE WORKFLOW MyModule.ApprovalWorkflow + * PARAMETER $WorkflowContext: MyModule.Request + * BEGIN + * USER TASK ReviewRequest 'Review the request' + * PAGE MyModule.ReviewPage + * OUTCOMES + * 'Approve' + * 'Reject' + * + * END + * END WORKFLOW; + * ``` + */ +createWorkflowStatement + : WORKFLOW qualifiedName + (PARAMETER VARIABLE COLON qualifiedName)? + (DISPLAY STRING_LITERAL)? + (DESCRIPTION STRING_LITERAL)? + (EXPORT LEVEL (IDENTIFIER | API))? + (OVERVIEW PAGE qualifiedName)? + (DUE DATE_TYPE STRING_LITERAL)? + BEGIN workflowBody END WORKFLOW SEMICOLON? SLASH? + ; + +workflowBody + : workflowActivityStmt* + ; + +workflowActivityStmt + : workflowUserTaskStmt SEMICOLON + | workflowCallMicroflowStmt SEMICOLON + | workflowCallWorkflowStmt SEMICOLON + | workflowDecisionStmt SEMICOLON + | workflowParallelSplitStmt SEMICOLON + | workflowJumpToStmt SEMICOLON + | workflowWaitForTimerStmt SEMICOLON + | workflowWaitForNotificationStmt SEMICOLON + | workflowAnnotationStmt SEMICOLON + ; + +workflowUserTaskStmt + : USER TASK IDENTIFIER STRING_LITERAL + (PAGE qualifiedName)? + (TARGETING MICROFLOW qualifiedName)? + (TARGETING XPATH STRING_LITERAL)? + (ENTITY qualifiedName)? + (DUE DATE_TYPE STRING_LITERAL)? + (DESCRIPTION STRING_LITERAL)? + (OUTCOMES workflowUserTaskOutcome+)? + (BOUNDARY EVENT workflowBoundaryEventClause+)? + | MULTI USER TASK IDENTIFIER STRING_LITERAL + (PAGE qualifiedName)? + (TARGETING MICROFLOW qualifiedName)? + (TARGETING XPATH STRING_LITERAL)? + (ENTITY qualifiedName)? + (DUE DATE_TYPE STRING_LITERAL)? + (DESCRIPTION STRING_LITERAL)? + (OUTCOMES workflowUserTaskOutcome+)? + (BOUNDARY EVENT workflowBoundaryEventClause+)? + ; + +workflowBoundaryEventClause + : INTERRUPTING TIMER STRING_LITERAL? (LBRACE workflowBody RBRACE)? + | NON INTERRUPTING TIMER STRING_LITERAL? (LBRACE workflowBody RBRACE)? + | TIMER STRING_LITERAL? (LBRACE workflowBody RBRACE)? + ; + +workflowUserTaskOutcome + : STRING_LITERAL LBRACE workflowBody RBRACE + ; + +workflowCallMicroflowStmt + : CALL MICROFLOW qualifiedName (COMMENT STRING_LITERAL)? + (WITH LPAREN workflowParameterMapping (COMMA workflowParameterMapping)* RPAREN)? + (OUTCOMES workflowConditionOutcome+)? + (BOUNDARY EVENT workflowBoundaryEventClause+)? + ; + +workflowParameterMapping + : qualifiedName EQUALS STRING_LITERAL + ; + +workflowCallWorkflowStmt + : CALL WORKFLOW qualifiedName (COMMENT STRING_LITERAL)? + (WITH LPAREN workflowParameterMapping (COMMA workflowParameterMapping)* RPAREN)? + ; + +workflowDecisionStmt + : DECISION STRING_LITERAL? (COMMENT STRING_LITERAL)? + (OUTCOMES workflowConditionOutcome+)? + ; + +workflowConditionOutcome + : (TRUE | FALSE | STRING_LITERAL | DEFAULT) ARROW LBRACE workflowBody RBRACE + ; + +workflowParallelSplitStmt + : PARALLEL SPLIT (COMMENT STRING_LITERAL)? + workflowParallelPath+ + ; + +workflowParallelPath + : PATH NUMBER_LITERAL LBRACE workflowBody RBRACE + ; + +workflowJumpToStmt + : JUMP TO IDENTIFIER (COMMENT STRING_LITERAL)? + ; + +workflowWaitForTimerStmt + : WAIT FOR TIMER STRING_LITERAL? (COMMENT STRING_LITERAL)? + ; + +workflowWaitForNotificationStmt + : WAIT FOR NOTIFICATION (COMMENT STRING_LITERAL)? + (BOUNDARY EVENT workflowBoundaryEventClause+)? + ; + +workflowAnnotationStmt + : ANNOTATION STRING_LITERAL + ; + +// workflowEndStmt removed - END activities are implicit and conflict with END WORKFLOW + // ============================================================================= // ALTER SETTINGS // ============================================================================= @@ -2252,6 +2398,7 @@ showStatement | SHOW ACCESS ON qualifiedName // SHOW ACCESS ON Module.Entity | SHOW ACCESS ON MICROFLOW qualifiedName // SHOW ACCESS ON MICROFLOW Module.MF | SHOW ACCESS ON PAGE qualifiedName // SHOW ACCESS ON PAGE Module.Page + | SHOW ACCESS ON WORKFLOW qualifiedName // SHOW ACCESS ON WORKFLOW Module.WF | SHOW SECURITY MATRIX (IN (qualifiedName | IDENTIFIER))? // SHOW SECURITY MATRIX [IN module] | SHOW ODATA CLIENTS (IN (qualifiedName | IDENTIFIER))? // SHOW ODATA CLIENTS [IN module] | SHOW ODATA SERVICES (IN (qualifiedName | IDENTIFIER))? // SHOW ODATA SERVICES [IN module] @@ -2955,7 +3102,8 @@ keyword | COLUMN | COLUMNS | LOCAL | PROJECT // Structure keywords | READ | WRITE | CATALOG | FORCE | DEPTH // Query/access keywords | JAVA | EVENTS | OVER | MEMBERS // Miscellaneous keywords - | WORKFLOWS | REFERENCES | CALLERS | CALLEES // Code search keywords + | WORKFLOW | WORKFLOWS | REFERENCES | CALLERS | CALLEES // Code search keywords + | TASK | DECISION | SPLIT | OUTCOMES | TARGETING | NOTIFICATION | TIMER | JUMP | DUE | OVERVIEW | DATE | PARALLEL | WAIT | BY // Workflow keywords | TRANSITIVE | IMPACT | SEARCH // Additional search keywords | BUSINESS | EVENT | SUBSCRIBE | SETTINGS | CONFIGURATION // Business events / settings keywords | DEFINE | FRAGMENT | FRAGMENTS // Fragment keywords diff --git a/mdl/grammar/parser/MDLLexer.interp b/mdl/grammar/parser/MDLLexer.interp index d64509e..4e5e16d 100644 --- a/mdl/grammar/parser/MDLLexer.interp +++ b/mdl/grammar/parser/MDLLexer.interp @@ -448,6 +448,27 @@ 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 '<=' '>=' '=' @@ -791,6 +812,7 @@ PATTERN EXPRESSION XPATH CONSTRAINT +CALCULATED REST SERVICE SERVICES @@ -929,9 +951,29 @@ APPLY ACCESS LEVEL USER +TASK +DECISION +SPLIT +OUTCOMES +TARGETING +NOTIFICATION +TIMER +JUMP +DUE +OVERVIEW +DATE +PARALLEL +WAIT +ANNOTATION +BOUNDARY +INTERRUPTING +NON +MULTI +BY READ WRITE DESCRIPTION +DISPLAY OFF USERS NOT_EQUALS @@ -1277,6 +1319,7 @@ PATTERN EXPRESSION XPATH CONSTRAINT +CALCULATED REST SERVICE SERVICES @@ -1415,9 +1458,29 @@ APPLY ACCESS LEVEL USER +TASK +DECISION +SPLIT +OUTCOMES +TARGETING +NOTIFICATION +TIMER +JUMP +DUE +OVERVIEW +DATE +PARALLEL +WAIT +ANNOTATION +BOUNDARY +INTERRUPTING +NON +MULTI +BY READ WRITE DESCRIPTION +DISPLAY OFF USERS NOT_EQUALS @@ -1495,4 +1558,4 @@ mode names: DEFAULT_MODE atn: -[4, 0, 484, 5030, 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, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 1, 0, 4, 0, 1029, 8, 0, 11, 0, 12, 0, 1030, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1040, 8, 1, 10, 1, 12, 1, 1043, 9, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 1052, 8, 2, 10, 2, 12, 2, 1055, 9, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 1066, 8, 3, 10, 3, 12, 3, 1069, 9, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 4, 4, 1076, 8, 4, 11, 4, 12, 4, 1077, 1, 4, 1, 4, 1, 4, 1, 4, 4, 4, 1084, 8, 4, 11, 4, 12, 4, 1085, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 4, 5, 1096, 8, 5, 11, 5, 12, 5, 1097, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 4, 6, 1109, 8, 6, 11, 6, 12, 6, 1110, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 4, 7, 1124, 8, 7, 11, 7, 12, 7, 1125, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 4, 8, 1137, 8, 8, 11, 8, 12, 8, 1138, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 4, 9, 1149, 8, 9, 11, 9, 12, 9, 1150, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1181, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 4, 12, 1192, 8, 12, 11, 12, 12, 12, 1193, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1206, 8, 13, 11, 13, 12, 13, 1207, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1214, 8, 13, 11, 13, 12, 13, 1215, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1271, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 4, 14, 1280, 8, 14, 11, 14, 12, 14, 1281, 1, 14, 1, 14, 1, 14, 1, 14, 4, 14, 1288, 8, 14, 11, 14, 12, 14, 1289, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 4, 14, 1297, 8, 14, 11, 14, 12, 14, 1298, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1363, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 4, 15, 1372, 8, 15, 11, 15, 12, 15, 1373, 1, 15, 1, 15, 1, 15, 4, 15, 1379, 8, 15, 11, 15, 12, 15, 1380, 1, 15, 1, 15, 1, 15, 4, 15, 1386, 8, 15, 11, 15, 12, 15, 1387, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1446, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1736, 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 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, 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, 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, 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, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 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, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 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, 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, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 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, 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, 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, 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, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 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, 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, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 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, 110, 1, 110, 1, 110, 1, 110, 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, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 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, 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, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 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, 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, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 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, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 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, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 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, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 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, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 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, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 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, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, 3, 447, 4794, 8, 447, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, 450, 1, 450, 1, 451, 1, 451, 1, 452, 1, 452, 1, 453, 1, 453, 1, 454, 1, 454, 1, 455, 1, 455, 1, 456, 1, 456, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 461, 1, 461, 1, 462, 1, 462, 1, 463, 1, 463, 1, 464, 1, 464, 1, 465, 1, 465, 1, 466, 1, 466, 1, 467, 1, 467, 1, 468, 1, 468, 1, 469, 1, 469, 1, 470, 1, 470, 1, 471, 1, 471, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 475, 1, 475, 1, 476, 1, 476, 1, 476, 1, 476, 5, 476, 4864, 8, 476, 10, 476, 12, 476, 4867, 9, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 5, 477, 4878, 8, 477, 10, 477, 12, 477, 4881, 9, 477, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 1, 478, 5, 478, 4889, 8, 478, 10, 478, 12, 478, 4892, 9, 478, 1, 478, 1, 478, 1, 478, 1, 479, 3, 479, 4898, 8, 479, 1, 479, 4, 479, 4901, 8, 479, 11, 479, 12, 479, 4902, 1, 479, 1, 479, 4, 479, 4907, 8, 479, 11, 479, 12, 479, 4908, 3, 479, 4911, 8, 479, 1, 479, 1, 479, 3, 479, 4915, 8, 479, 1, 479, 4, 479, 4918, 8, 479, 11, 479, 12, 479, 4919, 3, 479, 4922, 8, 479, 1, 480, 1, 480, 4, 480, 4926, 8, 480, 11, 480, 12, 480, 4927, 1, 481, 1, 481, 5, 481, 4932, 8, 481, 10, 481, 12, 481, 4935, 9, 481, 1, 482, 1, 482, 5, 482, 4939, 8, 482, 10, 482, 12, 482, 4942, 9, 482, 1, 482, 4, 482, 4945, 8, 482, 11, 482, 12, 482, 4946, 1, 482, 5, 482, 4950, 8, 482, 10, 482, 12, 482, 4953, 9, 482, 1, 483, 1, 483, 5, 483, 4957, 8, 483, 10, 483, 12, 483, 4960, 9, 483, 1, 483, 1, 483, 1, 483, 5, 483, 4965, 8, 483, 10, 483, 12, 483, 4968, 9, 483, 1, 483, 3, 483, 4971, 8, 483, 1, 484, 1, 484, 1, 485, 1, 485, 1, 486, 1, 486, 1, 487, 1, 487, 1, 488, 1, 488, 1, 489, 1, 489, 1, 490, 1, 490, 1, 491, 1, 491, 1, 492, 1, 492, 1, 493, 1, 493, 1, 494, 1, 494, 1, 495, 1, 495, 1, 496, 1, 496, 1, 497, 1, 497, 1, 498, 1, 498, 1, 499, 1, 499, 1, 500, 1, 500, 1, 501, 1, 501, 1, 502, 1, 502, 1, 503, 1, 503, 1, 504, 1, 504, 1, 505, 1, 505, 1, 506, 1, 506, 1, 507, 1, 507, 1, 508, 1, 508, 1, 509, 1, 509, 1, 510, 1, 510, 1, 511, 1, 511, 1, 512, 1, 512, 4, 1041, 1053, 4865, 4890, 0, 513, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, 255, 511, 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, 525, 263, 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, 270, 541, 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, 555, 278, 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, 285, 571, 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, 585, 293, 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, 300, 601, 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, 615, 308, 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, 315, 631, 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, 645, 323, 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, 330, 661, 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, 675, 338, 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, 345, 691, 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, 705, 353, 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, 360, 721, 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, 735, 368, 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, 375, 751, 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, 765, 383, 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, 779, 390, 781, 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, 397, 795, 398, 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, 809, 405, 811, 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, 412, 825, 413, 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, 839, 420, 841, 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, 427, 855, 428, 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, 869, 435, 871, 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, 442, 885, 443, 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, 899, 450, 901, 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, 457, 915, 458, 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, 929, 465, 931, 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, 472, 945, 473, 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, 959, 480, 961, 481, 963, 482, 965, 483, 967, 484, 969, 0, 971, 0, 973, 0, 975, 0, 977, 0, 979, 0, 981, 0, 983, 0, 985, 0, 987, 0, 989, 0, 991, 0, 993, 0, 995, 0, 997, 0, 999, 0, 1001, 0, 1003, 0, 1005, 0, 1007, 0, 1009, 0, 1011, 0, 1013, 0, 1015, 0, 1017, 0, 1019, 0, 1021, 0, 1023, 0, 1025, 0, 1, 0, 35, 2, 0, 9, 13, 32, 32, 2, 0, 10, 10, 13, 13, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 3, 0, 10, 10, 13, 13, 34, 34, 3, 0, 10, 10, 13, 13, 96, 96, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1, 0, 48, 57, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 5049, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, 813, 1, 0, 0, 0, 0, 815, 1, 0, 0, 0, 0, 817, 1, 0, 0, 0, 0, 819, 1, 0, 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, 1, 0, 0, 0, 0, 829, 1, 0, 0, 0, 0, 831, 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, 0, 835, 1, 0, 0, 0, 0, 837, 1, 0, 0, 0, 0, 839, 1, 0, 0, 0, 0, 841, 1, 0, 0, 0, 0, 843, 1, 0, 0, 0, 0, 845, 1, 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, 849, 1, 0, 0, 0, 0, 851, 1, 0, 0, 0, 0, 853, 1, 0, 0, 0, 0, 855, 1, 0, 0, 0, 0, 857, 1, 0, 0, 0, 0, 859, 1, 0, 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, 1, 0, 0, 0, 0, 865, 1, 0, 0, 0, 0, 867, 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, 0, 871, 1, 0, 0, 0, 0, 873, 1, 0, 0, 0, 0, 875, 1, 0, 0, 0, 0, 877, 1, 0, 0, 0, 0, 879, 1, 0, 0, 0, 0, 881, 1, 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, 885, 1, 0, 0, 0, 0, 887, 1, 0, 0, 0, 0, 889, 1, 0, 0, 0, 0, 891, 1, 0, 0, 0, 0, 893, 1, 0, 0, 0, 0, 895, 1, 0, 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, 1, 0, 0, 0, 0, 901, 1, 0, 0, 0, 0, 903, 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, 0, 907, 1, 0, 0, 0, 0, 909, 1, 0, 0, 0, 0, 911, 1, 0, 0, 0, 0, 913, 1, 0, 0, 0, 0, 915, 1, 0, 0, 0, 0, 917, 1, 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, 921, 1, 0, 0, 0, 0, 923, 1, 0, 0, 0, 0, 925, 1, 0, 0, 0, 0, 927, 1, 0, 0, 0, 0, 929, 1, 0, 0, 0, 0, 931, 1, 0, 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, 1, 0, 0, 0, 0, 937, 1, 0, 0, 0, 0, 939, 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, 0, 943, 1, 0, 0, 0, 0, 945, 1, 0, 0, 0, 0, 947, 1, 0, 0, 0, 0, 949, 1, 0, 0, 0, 0, 951, 1, 0, 0, 0, 0, 953, 1, 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, 957, 1, 0, 0, 0, 0, 959, 1, 0, 0, 0, 0, 961, 1, 0, 0, 0, 0, 963, 1, 0, 0, 0, 0, 965, 1, 0, 0, 0, 0, 967, 1, 0, 0, 0, 1, 1028, 1, 0, 0, 0, 3, 1034, 1, 0, 0, 0, 5, 1047, 1, 0, 0, 0, 7, 1061, 1, 0, 0, 0, 9, 1072, 1, 0, 0, 0, 11, 1092, 1, 0, 0, 0, 13, 1104, 1, 0, 0, 0, 15, 1117, 1, 0, 0, 0, 17, 1130, 1, 0, 0, 0, 19, 1143, 1, 0, 0, 0, 21, 1155, 1, 0, 0, 0, 23, 1170, 1, 0, 0, 0, 25, 1186, 1, 0, 0, 0, 27, 1270, 1, 0, 0, 0, 29, 1362, 1, 0, 0, 0, 31, 1445, 1, 0, 0, 0, 33, 1447, 1, 0, 0, 0, 35, 1454, 1, 0, 0, 0, 37, 1460, 1, 0, 0, 0, 39, 1465, 1, 0, 0, 0, 41, 1472, 1, 0, 0, 0, 43, 1477, 1, 0, 0, 0, 45, 1484, 1, 0, 0, 0, 47, 1491, 1, 0, 0, 0, 49, 1502, 1, 0, 0, 0, 51, 1507, 1, 0, 0, 0, 53, 1516, 1, 0, 0, 0, 55, 1528, 1, 0, 0, 0, 57, 1540, 1, 0, 0, 0, 59, 1547, 1, 0, 0, 0, 61, 1557, 1, 0, 0, 0, 63, 1566, 1, 0, 0, 0, 65, 1575, 1, 0, 0, 0, 67, 1580, 1, 0, 0, 0, 69, 1588, 1, 0, 0, 0, 71, 1595, 1, 0, 0, 0, 73, 1604, 1, 0, 0, 0, 75, 1613, 1, 0, 0, 0, 77, 1623, 1, 0, 0, 0, 79, 1630, 1, 0, 0, 0, 81, 1638, 1, 0, 0, 0, 83, 1644, 1, 0, 0, 0, 85, 1650, 1, 0, 0, 0, 87, 1660, 1, 0, 0, 0, 89, 1675, 1, 0, 0, 0, 91, 1683, 1, 0, 0, 0, 93, 1687, 1, 0, 0, 0, 95, 1691, 1, 0, 0, 0, 97, 1700, 1, 0, 0, 0, 99, 1714, 1, 0, 0, 0, 101, 1722, 1, 0, 0, 0, 103, 1728, 1, 0, 0, 0, 105, 1746, 1, 0, 0, 0, 107, 1754, 1, 0, 0, 0, 109, 1762, 1, 0, 0, 0, 111, 1770, 1, 0, 0, 0, 113, 1781, 1, 0, 0, 0, 115, 1787, 1, 0, 0, 0, 117, 1795, 1, 0, 0, 0, 119, 1803, 1, 0, 0, 0, 121, 1810, 1, 0, 0, 0, 123, 1816, 1, 0, 0, 0, 125, 1821, 1, 0, 0, 0, 127, 1826, 1, 0, 0, 0, 129, 1831, 1, 0, 0, 0, 131, 1840, 1, 0, 0, 0, 133, 1844, 1, 0, 0, 0, 135, 1855, 1, 0, 0, 0, 137, 1861, 1, 0, 0, 0, 139, 1868, 1, 0, 0, 0, 141, 1873, 1, 0, 0, 0, 143, 1879, 1, 0, 0, 0, 145, 1886, 1, 0, 0, 0, 147, 1893, 1, 0, 0, 0, 149, 1899, 1, 0, 0, 0, 151, 1902, 1, 0, 0, 0, 153, 1910, 1, 0, 0, 0, 155, 1920, 1, 0, 0, 0, 157, 1925, 1, 0, 0, 0, 159, 1930, 1, 0, 0, 0, 161, 1935, 1, 0, 0, 0, 163, 1940, 1, 0, 0, 0, 165, 1944, 1, 0, 0, 0, 167, 1953, 1, 0, 0, 0, 169, 1957, 1, 0, 0, 0, 171, 1962, 1, 0, 0, 0, 173, 1967, 1, 0, 0, 0, 175, 1973, 1, 0, 0, 0, 177, 1979, 1, 0, 0, 0, 179, 1985, 1, 0, 0, 0, 181, 1990, 1, 0, 0, 0, 183, 1996, 1, 0, 0, 0, 185, 1999, 1, 0, 0, 0, 187, 2003, 1, 0, 0, 0, 189, 2008, 1, 0, 0, 0, 191, 2014, 1, 0, 0, 0, 193, 2022, 1, 0, 0, 0, 195, 2029, 1, 0, 0, 0, 197, 2038, 1, 0, 0, 0, 199, 2045, 1, 0, 0, 0, 201, 2052, 1, 0, 0, 0, 203, 2061, 1, 0, 0, 0, 205, 2066, 1, 0, 0, 0, 207, 2072, 1, 0, 0, 0, 209, 2075, 1, 0, 0, 0, 211, 2081, 1, 0, 0, 0, 213, 2088, 1, 0, 0, 0, 215, 2097, 1, 0, 0, 0, 217, 2103, 1, 0, 0, 0, 219, 2110, 1, 0, 0, 0, 221, 2116, 1, 0, 0, 0, 223, 2120, 1, 0, 0, 0, 225, 2125, 1, 0, 0, 0, 227, 2130, 1, 0, 0, 0, 229, 2137, 1, 0, 0, 0, 231, 2145, 1, 0, 0, 0, 233, 2151, 1, 0, 0, 0, 235, 2156, 1, 0, 0, 0, 237, 2163, 1, 0, 0, 0, 239, 2168, 1, 0, 0, 0, 241, 2173, 1, 0, 0, 0, 243, 2178, 1, 0, 0, 0, 245, 2183, 1, 0, 0, 0, 247, 2189, 1, 0, 0, 0, 249, 2199, 1, 0, 0, 0, 251, 2208, 1, 0, 0, 0, 253, 2217, 1, 0, 0, 0, 255, 2225, 1, 0, 0, 0, 257, 2233, 1, 0, 0, 0, 259, 2241, 1, 0, 0, 0, 261, 2246, 1, 0, 0, 0, 263, 2253, 1, 0, 0, 0, 265, 2260, 1, 0, 0, 0, 267, 2265, 1, 0, 0, 0, 269, 2273, 1, 0, 0, 0, 271, 2279, 1, 0, 0, 0, 273, 2288, 1, 0, 0, 0, 275, 2293, 1, 0, 0, 0, 277, 2299, 1, 0, 0, 0, 279, 2306, 1, 0, 0, 0, 281, 2314, 1, 0, 0, 0, 283, 2320, 1, 0, 0, 0, 285, 2328, 1, 0, 0, 0, 287, 2337, 1, 0, 0, 0, 289, 2347, 1, 0, 0, 0, 291, 2359, 1, 0, 0, 0, 293, 2371, 1, 0, 0, 0, 295, 2382, 1, 0, 0, 0, 297, 2391, 1, 0, 0, 0, 299, 2400, 1, 0, 0, 0, 301, 2409, 1, 0, 0, 0, 303, 2417, 1, 0, 0, 0, 305, 2427, 1, 0, 0, 0, 307, 2431, 1, 0, 0, 0, 309, 2436, 1, 0, 0, 0, 311, 2447, 1, 0, 0, 0, 313, 2454, 1, 0, 0, 0, 315, 2464, 1, 0, 0, 0, 317, 2479, 1, 0, 0, 0, 319, 2492, 1, 0, 0, 0, 321, 2503, 1, 0, 0, 0, 323, 2510, 1, 0, 0, 0, 325, 2516, 1, 0, 0, 0, 327, 2528, 1, 0, 0, 0, 329, 2536, 1, 0, 0, 0, 331, 2547, 1, 0, 0, 0, 333, 2553, 1, 0, 0, 0, 335, 2561, 1, 0, 0, 0, 337, 2570, 1, 0, 0, 0, 339, 2581, 1, 0, 0, 0, 341, 2594, 1, 0, 0, 0, 343, 2603, 1, 0, 0, 0, 345, 2612, 1, 0, 0, 0, 347, 2621, 1, 0, 0, 0, 349, 2639, 1, 0, 0, 0, 351, 2665, 1, 0, 0, 0, 353, 2675, 1, 0, 0, 0, 355, 2686, 1, 0, 0, 0, 357, 2699, 1, 0, 0, 0, 359, 2710, 1, 0, 0, 0, 361, 2723, 1, 0, 0, 0, 363, 2738, 1, 0, 0, 0, 365, 2749, 1, 0, 0, 0, 367, 2756, 1, 0, 0, 0, 369, 2763, 1, 0, 0, 0, 371, 2771, 1, 0, 0, 0, 373, 2779, 1, 0, 0, 0, 375, 2784, 1, 0, 0, 0, 377, 2792, 1, 0, 0, 0, 379, 2803, 1, 0, 0, 0, 381, 2810, 1, 0, 0, 0, 383, 2820, 1, 0, 0, 0, 385, 2827, 1, 0, 0, 0, 387, 2834, 1, 0, 0, 0, 389, 2842, 1, 0, 0, 0, 391, 2853, 1, 0, 0, 0, 393, 2859, 1, 0, 0, 0, 395, 2864, 1, 0, 0, 0, 397, 2878, 1, 0, 0, 0, 399, 2892, 1, 0, 0, 0, 401, 2899, 1, 0, 0, 0, 403, 2909, 1, 0, 0, 0, 405, 2922, 1, 0, 0, 0, 407, 2928, 1, 0, 0, 0, 409, 2934, 1, 0, 0, 0, 411, 2946, 1, 0, 0, 0, 413, 2953, 1, 0, 0, 0, 415, 2964, 1, 0, 0, 0, 417, 2981, 1, 0, 0, 0, 419, 2989, 1, 0, 0, 0, 421, 2995, 1, 0, 0, 0, 423, 3001, 1, 0, 0, 0, 425, 3008, 1, 0, 0, 0, 427, 3017, 1, 0, 0, 0, 429, 3021, 1, 0, 0, 0, 431, 3028, 1, 0, 0, 0, 433, 3036, 1, 0, 0, 0, 435, 3044, 1, 0, 0, 0, 437, 3053, 1, 0, 0, 0, 439, 3062, 1, 0, 0, 0, 441, 3073, 1, 0, 0, 0, 443, 3084, 1, 0, 0, 0, 445, 3090, 1, 0, 0, 0, 447, 3102, 1, 0, 0, 0, 449, 3115, 1, 0, 0, 0, 451, 3131, 1, 0, 0, 0, 453, 3140, 1, 0, 0, 0, 455, 3148, 1, 0, 0, 0, 457, 3160, 1, 0, 0, 0, 459, 3173, 1, 0, 0, 0, 461, 3188, 1, 0, 0, 0, 463, 3199, 1, 0, 0, 0, 465, 3209, 1, 0, 0, 0, 467, 3223, 1, 0, 0, 0, 469, 3237, 1, 0, 0, 0, 471, 3251, 1, 0, 0, 0, 473, 3266, 1, 0, 0, 0, 475, 3280, 1, 0, 0, 0, 477, 3290, 1, 0, 0, 0, 479, 3299, 1, 0, 0, 0, 481, 3306, 1, 0, 0, 0, 483, 3314, 1, 0, 0, 0, 485, 3322, 1, 0, 0, 0, 487, 3329, 1, 0, 0, 0, 489, 3337, 1, 0, 0, 0, 491, 3342, 1, 0, 0, 0, 493, 3351, 1, 0, 0, 0, 495, 3359, 1, 0, 0, 0, 497, 3368, 1, 0, 0, 0, 499, 3377, 1, 0, 0, 0, 501, 3380, 1, 0, 0, 0, 503, 3383, 1, 0, 0, 0, 505, 3386, 1, 0, 0, 0, 507, 3389, 1, 0, 0, 0, 509, 3392, 1, 0, 0, 0, 511, 3395, 1, 0, 0, 0, 513, 3405, 1, 0, 0, 0, 515, 3412, 1, 0, 0, 0, 517, 3420, 1, 0, 0, 0, 519, 3425, 1, 0, 0, 0, 521, 3433, 1, 0, 0, 0, 523, 3441, 1, 0, 0, 0, 525, 3450, 1, 0, 0, 0, 527, 3455, 1, 0, 0, 0, 529, 3466, 1, 0, 0, 0, 531, 3473, 1, 0, 0, 0, 533, 3486, 1, 0, 0, 0, 535, 3495, 1, 0, 0, 0, 537, 3501, 1, 0, 0, 0, 539, 3516, 1, 0, 0, 0, 541, 3521, 1, 0, 0, 0, 543, 3527, 1, 0, 0, 0, 545, 3531, 1, 0, 0, 0, 547, 3535, 1, 0, 0, 0, 549, 3539, 1, 0, 0, 0, 551, 3543, 1, 0, 0, 0, 553, 3550, 1, 0, 0, 0, 555, 3555, 1, 0, 0, 0, 557, 3564, 1, 0, 0, 0, 559, 3569, 1, 0, 0, 0, 561, 3573, 1, 0, 0, 0, 563, 3576, 1, 0, 0, 0, 565, 3580, 1, 0, 0, 0, 567, 3585, 1, 0, 0, 0, 569, 3588, 1, 0, 0, 0, 571, 3596, 1, 0, 0, 0, 573, 3601, 1, 0, 0, 0, 575, 3607, 1, 0, 0, 0, 577, 3614, 1, 0, 0, 0, 579, 3621, 1, 0, 0, 0, 581, 3629, 1, 0, 0, 0, 583, 3634, 1, 0, 0, 0, 585, 3640, 1, 0, 0, 0, 587, 3651, 1, 0, 0, 0, 589, 3660, 1, 0, 0, 0, 591, 3665, 1, 0, 0, 0, 593, 3674, 1, 0, 0, 0, 595, 3680, 1, 0, 0, 0, 597, 3686, 1, 0, 0, 0, 599, 3692, 1, 0, 0, 0, 601, 3698, 1, 0, 0, 0, 603, 3706, 1, 0, 0, 0, 605, 3717, 1, 0, 0, 0, 607, 3723, 1, 0, 0, 0, 609, 3734, 1, 0, 0, 0, 611, 3739, 1, 0, 0, 0, 613, 3747, 1, 0, 0, 0, 615, 3756, 1, 0, 0, 0, 617, 3762, 1, 0, 0, 0, 619, 3767, 1, 0, 0, 0, 621, 3772, 1, 0, 0, 0, 623, 3787, 1, 0, 0, 0, 625, 3793, 1, 0, 0, 0, 627, 3801, 1, 0, 0, 0, 629, 3807, 1, 0, 0, 0, 631, 3817, 1, 0, 0, 0, 633, 3824, 1, 0, 0, 0, 635, 3829, 1, 0, 0, 0, 637, 3837, 1, 0, 0, 0, 639, 3842, 1, 0, 0, 0, 641, 3851, 1, 0, 0, 0, 643, 3859, 1, 0, 0, 0, 645, 3864, 1, 0, 0, 0, 647, 3868, 1, 0, 0, 0, 649, 3875, 1, 0, 0, 0, 651, 3883, 1, 0, 0, 0, 653, 3887, 1, 0, 0, 0, 655, 3892, 1, 0, 0, 0, 657, 3896, 1, 0, 0, 0, 659, 3902, 1, 0, 0, 0, 661, 3906, 1, 0, 0, 0, 663, 3913, 1, 0, 0, 0, 665, 3921, 1, 0, 0, 0, 667, 3929, 1, 0, 0, 0, 669, 3936, 1, 0, 0, 0, 671, 3946, 1, 0, 0, 0, 673, 3954, 1, 0, 0, 0, 675, 3960, 1, 0, 0, 0, 677, 3967, 1, 0, 0, 0, 679, 3981, 1, 0, 0, 0, 681, 3990, 1, 0, 0, 0, 683, 3999, 1, 0, 0, 0, 685, 4010, 1, 0, 0, 0, 687, 4019, 1, 0, 0, 0, 689, 4025, 1, 0, 0, 0, 691, 4029, 1, 0, 0, 0, 693, 4037, 1, 0, 0, 0, 695, 4044, 1, 0, 0, 0, 697, 4049, 1, 0, 0, 0, 699, 4055, 1, 0, 0, 0, 701, 4060, 1, 0, 0, 0, 703, 4067, 1, 0, 0, 0, 705, 4076, 1, 0, 0, 0, 707, 4086, 1, 0, 0, 0, 709, 4091, 1, 0, 0, 0, 711, 4098, 1, 0, 0, 0, 713, 4104, 1, 0, 0, 0, 715, 4112, 1, 0, 0, 0, 717, 4122, 1, 0, 0, 0, 719, 4133, 1, 0, 0, 0, 721, 4141, 1, 0, 0, 0, 723, 4152, 1, 0, 0, 0, 725, 4157, 1, 0, 0, 0, 727, 4163, 1, 0, 0, 0, 729, 4168, 1, 0, 0, 0, 731, 4174, 1, 0, 0, 0, 733, 4180, 1, 0, 0, 0, 735, 4188, 1, 0, 0, 0, 737, 4197, 1, 0, 0, 0, 739, 4210, 1, 0, 0, 0, 741, 4221, 1, 0, 0, 0, 743, 4231, 1, 0, 0, 0, 745, 4241, 1, 0, 0, 0, 747, 4254, 1, 0, 0, 0, 749, 4264, 1, 0, 0, 0, 751, 4276, 1, 0, 0, 0, 753, 4283, 1, 0, 0, 0, 755, 4292, 1, 0, 0, 0, 757, 4302, 1, 0, 0, 0, 759, 4309, 1, 0, 0, 0, 761, 4316, 1, 0, 0, 0, 763, 4322, 1, 0, 0, 0, 765, 4329, 1, 0, 0, 0, 767, 4337, 1, 0, 0, 0, 769, 4343, 1, 0, 0, 0, 771, 4349, 1, 0, 0, 0, 773, 4357, 1, 0, 0, 0, 775, 4364, 1, 0, 0, 0, 777, 4369, 1, 0, 0, 0, 779, 4375, 1, 0, 0, 0, 781, 4380, 1, 0, 0, 0, 783, 4386, 1, 0, 0, 0, 785, 4394, 1, 0, 0, 0, 787, 4402, 1, 0, 0, 0, 789, 4410, 1, 0, 0, 0, 791, 4416, 1, 0, 0, 0, 793, 4427, 1, 0, 0, 0, 795, 4435, 1, 0, 0, 0, 797, 4443, 1, 0, 0, 0, 799, 4454, 1, 0, 0, 0, 801, 4465, 1, 0, 0, 0, 803, 4472, 1, 0, 0, 0, 805, 4478, 1, 0, 0, 0, 807, 4488, 1, 0, 0, 0, 809, 4493, 1, 0, 0, 0, 811, 4499, 1, 0, 0, 0, 813, 4506, 1, 0, 0, 0, 815, 4515, 1, 0, 0, 0, 817, 4520, 1, 0, 0, 0, 819, 4525, 1, 0, 0, 0, 821, 4528, 1, 0, 0, 0, 823, 4531, 1, 0, 0, 0, 825, 4536, 1, 0, 0, 0, 827, 4540, 1, 0, 0, 0, 829, 4548, 1, 0, 0, 0, 831, 4556, 1, 0, 0, 0, 833, 4570, 1, 0, 0, 0, 835, 4577, 1, 0, 0, 0, 837, 4581, 1, 0, 0, 0, 839, 4589, 1, 0, 0, 0, 841, 4593, 1, 0, 0, 0, 843, 4597, 1, 0, 0, 0, 845, 4608, 1, 0, 0, 0, 847, 4611, 1, 0, 0, 0, 849, 4620, 1, 0, 0, 0, 851, 4626, 1, 0, 0, 0, 853, 4636, 1, 0, 0, 0, 855, 4645, 1, 0, 0, 0, 857, 4659, 1, 0, 0, 0, 859, 4668, 1, 0, 0, 0, 861, 4673, 1, 0, 0, 0, 863, 4679, 1, 0, 0, 0, 865, 4685, 1, 0, 0, 0, 867, 4692, 1, 0, 0, 0, 869, 4703, 1, 0, 0, 0, 871, 4713, 1, 0, 0, 0, 873, 4720, 1, 0, 0, 0, 875, 4725, 1, 0, 0, 0, 877, 4732, 1, 0, 0, 0, 879, 4738, 1, 0, 0, 0, 881, 4745, 1, 0, 0, 0, 883, 4751, 1, 0, 0, 0, 885, 4756, 1, 0, 0, 0, 887, 4761, 1, 0, 0, 0, 889, 4767, 1, 0, 0, 0, 891, 4779, 1, 0, 0, 0, 893, 4783, 1, 0, 0, 0, 895, 4793, 1, 0, 0, 0, 897, 4795, 1, 0, 0, 0, 899, 4798, 1, 0, 0, 0, 901, 4801, 1, 0, 0, 0, 903, 4803, 1, 0, 0, 0, 905, 4805, 1, 0, 0, 0, 907, 4807, 1, 0, 0, 0, 909, 4809, 1, 0, 0, 0, 911, 4811, 1, 0, 0, 0, 913, 4813, 1, 0, 0, 0, 915, 4815, 1, 0, 0, 0, 917, 4817, 1, 0, 0, 0, 919, 4821, 1, 0, 0, 0, 921, 4825, 1, 0, 0, 0, 923, 4827, 1, 0, 0, 0, 925, 4829, 1, 0, 0, 0, 927, 4831, 1, 0, 0, 0, 929, 4833, 1, 0, 0, 0, 931, 4835, 1, 0, 0, 0, 933, 4837, 1, 0, 0, 0, 935, 4839, 1, 0, 0, 0, 937, 4841, 1, 0, 0, 0, 939, 4843, 1, 0, 0, 0, 941, 4845, 1, 0, 0, 0, 943, 4847, 1, 0, 0, 0, 945, 4849, 1, 0, 0, 0, 947, 4852, 1, 0, 0, 0, 949, 4855, 1, 0, 0, 0, 951, 4857, 1, 0, 0, 0, 953, 4859, 1, 0, 0, 0, 955, 4871, 1, 0, 0, 0, 957, 4884, 1, 0, 0, 0, 959, 4897, 1, 0, 0, 0, 961, 4923, 1, 0, 0, 0, 963, 4929, 1, 0, 0, 0, 965, 4936, 1, 0, 0, 0, 967, 4970, 1, 0, 0, 0, 969, 4972, 1, 0, 0, 0, 971, 4974, 1, 0, 0, 0, 973, 4976, 1, 0, 0, 0, 975, 4978, 1, 0, 0, 0, 977, 4980, 1, 0, 0, 0, 979, 4982, 1, 0, 0, 0, 981, 4984, 1, 0, 0, 0, 983, 4986, 1, 0, 0, 0, 985, 4988, 1, 0, 0, 0, 987, 4990, 1, 0, 0, 0, 989, 4992, 1, 0, 0, 0, 991, 4994, 1, 0, 0, 0, 993, 4996, 1, 0, 0, 0, 995, 4998, 1, 0, 0, 0, 997, 5000, 1, 0, 0, 0, 999, 5002, 1, 0, 0, 0, 1001, 5004, 1, 0, 0, 0, 1003, 5006, 1, 0, 0, 0, 1005, 5008, 1, 0, 0, 0, 1007, 5010, 1, 0, 0, 0, 1009, 5012, 1, 0, 0, 0, 1011, 5014, 1, 0, 0, 0, 1013, 5016, 1, 0, 0, 0, 1015, 5018, 1, 0, 0, 0, 1017, 5020, 1, 0, 0, 0, 1019, 5022, 1, 0, 0, 0, 1021, 5024, 1, 0, 0, 0, 1023, 5026, 1, 0, 0, 0, 1025, 5028, 1, 0, 0, 0, 1027, 1029, 7, 0, 0, 0, 1028, 1027, 1, 0, 0, 0, 1029, 1030, 1, 0, 0, 0, 1030, 1028, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, 0, 1032, 1033, 6, 0, 0, 0, 1033, 2, 1, 0, 0, 0, 1034, 1035, 5, 47, 0, 0, 1035, 1036, 5, 42, 0, 0, 1036, 1037, 5, 42, 0, 0, 1037, 1041, 1, 0, 0, 0, 1038, 1040, 9, 0, 0, 0, 1039, 1038, 1, 0, 0, 0, 1040, 1043, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1041, 1039, 1, 0, 0, 0, 1042, 1044, 1, 0, 0, 0, 1043, 1041, 1, 0, 0, 0, 1044, 1045, 5, 42, 0, 0, 1045, 1046, 5, 47, 0, 0, 1046, 4, 1, 0, 0, 0, 1047, 1048, 5, 47, 0, 0, 1048, 1049, 5, 42, 0, 0, 1049, 1053, 1, 0, 0, 0, 1050, 1052, 9, 0, 0, 0, 1051, 1050, 1, 0, 0, 0, 1052, 1055, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1053, 1051, 1, 0, 0, 0, 1054, 1056, 1, 0, 0, 0, 1055, 1053, 1, 0, 0, 0, 1056, 1057, 5, 42, 0, 0, 1057, 1058, 5, 47, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1060, 6, 2, 0, 0, 1060, 6, 1, 0, 0, 0, 1061, 1062, 5, 45, 0, 0, 1062, 1063, 5, 45, 0, 0, 1063, 1067, 1, 0, 0, 0, 1064, 1066, 8, 1, 0, 0, 1065, 1064, 1, 0, 0, 0, 1066, 1069, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1071, 6, 3, 0, 0, 1071, 8, 1, 0, 0, 0, 1072, 1073, 3, 991, 495, 0, 1073, 1075, 3, 1011, 505, 0, 1074, 1076, 3, 1, 0, 0, 1075, 1074, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077, 1075, 1, 0, 0, 0, 1077, 1078, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1080, 3, 1001, 500, 0, 1080, 1081, 3, 1003, 501, 0, 1081, 1083, 3, 1013, 506, 0, 1082, 1084, 3, 1, 0, 0, 1083, 1082, 1, 0, 0, 0, 1084, 1085, 1, 0, 0, 0, 1085, 1083, 1, 0, 0, 0, 1085, 1086, 1, 0, 0, 0, 1086, 1087, 1, 0, 0, 0, 1087, 1088, 3, 1001, 500, 0, 1088, 1089, 3, 1015, 507, 0, 1089, 1090, 3, 997, 498, 0, 1090, 1091, 3, 997, 498, 0, 1091, 10, 1, 0, 0, 0, 1092, 1093, 3, 991, 495, 0, 1093, 1095, 3, 1011, 505, 0, 1094, 1096, 3, 1, 0, 0, 1095, 1094, 1, 0, 0, 0, 1096, 1097, 1, 0, 0, 0, 1097, 1095, 1, 0, 0, 0, 1097, 1098, 1, 0, 0, 0, 1098, 1099, 1, 0, 0, 0, 1099, 1100, 3, 1001, 500, 0, 1100, 1101, 3, 1015, 507, 0, 1101, 1102, 3, 997, 498, 0, 1102, 1103, 3, 997, 498, 0, 1103, 12, 1, 0, 0, 0, 1104, 1105, 3, 1001, 500, 0, 1105, 1106, 3, 1003, 501, 0, 1106, 1108, 3, 1013, 506, 0, 1107, 1109, 3, 1, 0, 0, 1108, 1107, 1, 0, 0, 0, 1109, 1110, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1110, 1111, 1, 0, 0, 0, 1111, 1112, 1, 0, 0, 0, 1112, 1113, 3, 1001, 500, 0, 1113, 1114, 3, 1015, 507, 0, 1114, 1115, 3, 997, 498, 0, 1115, 1116, 3, 997, 498, 0, 1116, 14, 1, 0, 0, 0, 1117, 1118, 3, 987, 493, 0, 1118, 1119, 3, 1009, 504, 0, 1119, 1120, 3, 1003, 501, 0, 1120, 1121, 3, 1015, 507, 0, 1121, 1123, 3, 1005, 502, 0, 1122, 1124, 3, 1, 0, 0, 1123, 1122, 1, 0, 0, 0, 1124, 1125, 1, 0, 0, 0, 1125, 1123, 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1128, 3, 977, 488, 0, 1128, 1129, 3, 1023, 511, 0, 1129, 16, 1, 0, 0, 0, 1130, 1131, 3, 1003, 501, 0, 1131, 1132, 3, 1009, 504, 0, 1132, 1133, 3, 981, 490, 0, 1133, 1134, 3, 983, 491, 0, 1134, 1136, 3, 1009, 504, 0, 1135, 1137, 3, 1, 0, 0, 1136, 1135, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1136, 1, 0, 0, 0, 1138, 1139, 1, 0, 0, 0, 1139, 1140, 1, 0, 0, 0, 1140, 1141, 3, 977, 488, 0, 1141, 1142, 3, 1023, 511, 0, 1142, 18, 1, 0, 0, 0, 1143, 1144, 3, 1011, 505, 0, 1144, 1145, 3, 1003, 501, 0, 1145, 1146, 3, 1009, 504, 0, 1146, 1148, 3, 1013, 506, 0, 1147, 1149, 3, 1, 0, 0, 1148, 1147, 1, 0, 0, 0, 1149, 1150, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1153, 3, 977, 488, 0, 1153, 1154, 3, 1023, 511, 0, 1154, 20, 1, 0, 0, 0, 1155, 1156, 3, 1001, 500, 0, 1156, 1157, 3, 1003, 501, 0, 1157, 1158, 3, 1001, 500, 0, 1158, 1159, 5, 45, 0, 0, 1159, 1160, 3, 1005, 502, 0, 1160, 1161, 3, 983, 491, 0, 1161, 1162, 3, 1009, 504, 0, 1162, 1163, 3, 1011, 505, 0, 1163, 1164, 3, 991, 495, 0, 1164, 1165, 3, 1011, 505, 0, 1165, 1166, 3, 1013, 506, 0, 1166, 1167, 3, 983, 491, 0, 1167, 1168, 3, 1001, 500, 0, 1168, 1169, 3, 1013, 506, 0, 1169, 22, 1, 0, 0, 0, 1170, 1171, 3, 1009, 504, 0, 1171, 1172, 3, 983, 491, 0, 1172, 1173, 3, 985, 492, 0, 1173, 1174, 3, 983, 491, 0, 1174, 1175, 3, 1009, 504, 0, 1175, 1176, 3, 983, 491, 0, 1176, 1177, 3, 1001, 500, 0, 1177, 1178, 3, 979, 489, 0, 1178, 1180, 3, 983, 491, 0, 1179, 1181, 5, 95, 0, 0, 1180, 1179, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1183, 3, 1011, 505, 0, 1183, 1184, 3, 983, 491, 0, 1184, 1185, 3, 1013, 506, 0, 1185, 24, 1, 0, 0, 0, 1186, 1187, 3, 997, 498, 0, 1187, 1188, 3, 991, 495, 0, 1188, 1189, 3, 1011, 505, 0, 1189, 1191, 3, 1013, 506, 0, 1190, 1192, 3, 1, 0, 0, 1191, 1190, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 1196, 3, 1003, 501, 0, 1196, 1197, 3, 985, 492, 0, 1197, 26, 1, 0, 0, 0, 1198, 1199, 3, 981, 490, 0, 1199, 1200, 3, 983, 491, 0, 1200, 1201, 3, 997, 498, 0, 1201, 1202, 3, 983, 491, 0, 1202, 1203, 3, 1013, 506, 0, 1203, 1205, 3, 983, 491, 0, 1204, 1206, 3, 1, 0, 0, 1205, 1204, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 1210, 3, 975, 487, 0, 1210, 1211, 3, 1001, 500, 0, 1211, 1213, 3, 981, 490, 0, 1212, 1214, 3, 1, 0, 0, 1213, 1212, 1, 0, 0, 0, 1214, 1215, 1, 0, 0, 0, 1215, 1213, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, 1218, 3, 1009, 504, 0, 1218, 1219, 3, 983, 491, 0, 1219, 1220, 3, 985, 492, 0, 1220, 1221, 3, 983, 491, 0, 1221, 1222, 3, 1009, 504, 0, 1222, 1223, 3, 983, 491, 0, 1223, 1224, 3, 1001, 500, 0, 1224, 1225, 3, 979, 489, 0, 1225, 1226, 3, 983, 491, 0, 1226, 1227, 3, 1011, 505, 0, 1227, 1271, 1, 0, 0, 0, 1228, 1229, 3, 981, 490, 0, 1229, 1230, 3, 983, 491, 0, 1230, 1231, 3, 997, 498, 0, 1231, 1232, 3, 983, 491, 0, 1232, 1233, 3, 1013, 506, 0, 1233, 1234, 3, 983, 491, 0, 1234, 1235, 5, 95, 0, 0, 1235, 1236, 3, 975, 487, 0, 1236, 1237, 3, 1001, 500, 0, 1237, 1238, 3, 981, 490, 0, 1238, 1239, 5, 95, 0, 0, 1239, 1240, 3, 1009, 504, 0, 1240, 1241, 3, 983, 491, 0, 1241, 1242, 3, 985, 492, 0, 1242, 1243, 3, 983, 491, 0, 1243, 1244, 3, 1009, 504, 0, 1244, 1245, 3, 983, 491, 0, 1245, 1246, 3, 1001, 500, 0, 1246, 1247, 3, 979, 489, 0, 1247, 1248, 3, 983, 491, 0, 1248, 1249, 3, 1011, 505, 0, 1249, 1271, 1, 0, 0, 0, 1250, 1251, 3, 981, 490, 0, 1251, 1252, 3, 983, 491, 0, 1252, 1253, 3, 997, 498, 0, 1253, 1254, 3, 983, 491, 0, 1254, 1255, 3, 1013, 506, 0, 1255, 1256, 3, 983, 491, 0, 1256, 1257, 3, 975, 487, 0, 1257, 1258, 3, 1001, 500, 0, 1258, 1259, 3, 981, 490, 0, 1259, 1260, 3, 1009, 504, 0, 1260, 1261, 3, 983, 491, 0, 1261, 1262, 3, 985, 492, 0, 1262, 1263, 3, 983, 491, 0, 1263, 1264, 3, 1009, 504, 0, 1264, 1265, 3, 983, 491, 0, 1265, 1266, 3, 1001, 500, 0, 1266, 1267, 3, 979, 489, 0, 1267, 1268, 3, 983, 491, 0, 1268, 1269, 3, 1011, 505, 0, 1269, 1271, 1, 0, 0, 0, 1270, 1198, 1, 0, 0, 0, 1270, 1228, 1, 0, 0, 0, 1270, 1250, 1, 0, 0, 0, 1271, 28, 1, 0, 0, 0, 1272, 1273, 3, 981, 490, 0, 1273, 1274, 3, 983, 491, 0, 1274, 1275, 3, 997, 498, 0, 1275, 1276, 3, 983, 491, 0, 1276, 1277, 3, 1013, 506, 0, 1277, 1279, 3, 983, 491, 0, 1278, 1280, 3, 1, 0, 0, 1279, 1278, 1, 0, 0, 0, 1280, 1281, 1, 0, 0, 0, 1281, 1279, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1283, 1, 0, 0, 0, 1283, 1284, 3, 977, 488, 0, 1284, 1285, 3, 1015, 507, 0, 1285, 1287, 3, 1013, 506, 0, 1286, 1288, 3, 1, 0, 0, 1287, 1286, 1, 0, 0, 0, 1288, 1289, 1, 0, 0, 0, 1289, 1287, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, 1291, 1, 0, 0, 0, 1291, 1292, 3, 995, 497, 0, 1292, 1293, 3, 983, 491, 0, 1293, 1294, 3, 983, 491, 0, 1294, 1296, 3, 1005, 502, 0, 1295, 1297, 3, 1, 0, 0, 1296, 1295, 1, 0, 0, 0, 1297, 1298, 1, 0, 0, 0, 1298, 1296, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1301, 3, 1009, 504, 0, 1301, 1302, 3, 983, 491, 0, 1302, 1303, 3, 985, 492, 0, 1303, 1304, 3, 983, 491, 0, 1304, 1305, 3, 1009, 504, 0, 1305, 1306, 3, 983, 491, 0, 1306, 1307, 3, 1001, 500, 0, 1307, 1308, 3, 979, 489, 0, 1308, 1309, 3, 983, 491, 0, 1309, 1310, 3, 1011, 505, 0, 1310, 1363, 1, 0, 0, 0, 1311, 1312, 3, 981, 490, 0, 1312, 1313, 3, 983, 491, 0, 1313, 1314, 3, 997, 498, 0, 1314, 1315, 3, 983, 491, 0, 1315, 1316, 3, 1013, 506, 0, 1316, 1317, 3, 983, 491, 0, 1317, 1318, 5, 95, 0, 0, 1318, 1319, 3, 977, 488, 0, 1319, 1320, 3, 1015, 507, 0, 1320, 1321, 3, 1013, 506, 0, 1321, 1322, 5, 95, 0, 0, 1322, 1323, 3, 995, 497, 0, 1323, 1324, 3, 983, 491, 0, 1324, 1325, 3, 983, 491, 0, 1325, 1326, 3, 1005, 502, 0, 1326, 1327, 5, 95, 0, 0, 1327, 1328, 3, 1009, 504, 0, 1328, 1329, 3, 983, 491, 0, 1329, 1330, 3, 985, 492, 0, 1330, 1331, 3, 983, 491, 0, 1331, 1332, 3, 1009, 504, 0, 1332, 1333, 3, 983, 491, 0, 1333, 1334, 3, 1001, 500, 0, 1334, 1335, 3, 979, 489, 0, 1335, 1336, 3, 983, 491, 0, 1336, 1337, 3, 1011, 505, 0, 1337, 1363, 1, 0, 0, 0, 1338, 1339, 3, 981, 490, 0, 1339, 1340, 3, 983, 491, 0, 1340, 1341, 3, 997, 498, 0, 1341, 1342, 3, 983, 491, 0, 1342, 1343, 3, 1013, 506, 0, 1343, 1344, 3, 983, 491, 0, 1344, 1345, 3, 977, 488, 0, 1345, 1346, 3, 1015, 507, 0, 1346, 1347, 3, 1013, 506, 0, 1347, 1348, 3, 995, 497, 0, 1348, 1349, 3, 983, 491, 0, 1349, 1350, 3, 983, 491, 0, 1350, 1351, 3, 1005, 502, 0, 1351, 1352, 3, 1009, 504, 0, 1352, 1353, 3, 983, 491, 0, 1353, 1354, 3, 985, 492, 0, 1354, 1355, 3, 983, 491, 0, 1355, 1356, 3, 1009, 504, 0, 1356, 1357, 3, 983, 491, 0, 1357, 1358, 3, 1001, 500, 0, 1358, 1359, 3, 979, 489, 0, 1359, 1360, 3, 983, 491, 0, 1360, 1361, 3, 1011, 505, 0, 1361, 1363, 1, 0, 0, 0, 1362, 1272, 1, 0, 0, 0, 1362, 1311, 1, 0, 0, 0, 1362, 1338, 1, 0, 0, 0, 1363, 30, 1, 0, 0, 0, 1364, 1365, 3, 981, 490, 0, 1365, 1366, 3, 983, 491, 0, 1366, 1367, 3, 997, 498, 0, 1367, 1368, 3, 983, 491, 0, 1368, 1369, 3, 1013, 506, 0, 1369, 1371, 3, 983, 491, 0, 1370, 1372, 3, 1, 0, 0, 1371, 1370, 1, 0, 0, 0, 1372, 1373, 1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1373, 1374, 1, 0, 0, 0, 1374, 1375, 1, 0, 0, 0, 1375, 1376, 3, 991, 495, 0, 1376, 1378, 3, 985, 492, 0, 1377, 1379, 3, 1, 0, 0, 1378, 1377, 1, 0, 0, 0, 1379, 1380, 1, 0, 0, 0, 1380, 1378, 1, 0, 0, 0, 1380, 1381, 1, 0, 0, 0, 1381, 1382, 1, 0, 0, 0, 1382, 1383, 3, 1001, 500, 0, 1383, 1385, 3, 1003, 501, 0, 1384, 1386, 3, 1, 0, 0, 1385, 1384, 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1385, 1, 0, 0, 0, 1387, 1388, 1, 0, 0, 0, 1388, 1389, 1, 0, 0, 0, 1389, 1390, 3, 1009, 504, 0, 1390, 1391, 3, 983, 491, 0, 1391, 1392, 3, 985, 492, 0, 1392, 1393, 3, 983, 491, 0, 1393, 1394, 3, 1009, 504, 0, 1394, 1395, 3, 983, 491, 0, 1395, 1396, 3, 1001, 500, 0, 1396, 1397, 3, 979, 489, 0, 1397, 1398, 3, 983, 491, 0, 1398, 1399, 3, 1011, 505, 0, 1399, 1446, 1, 0, 0, 0, 1400, 1401, 3, 981, 490, 0, 1401, 1402, 3, 983, 491, 0, 1402, 1403, 3, 997, 498, 0, 1403, 1404, 3, 983, 491, 0, 1404, 1405, 3, 1013, 506, 0, 1405, 1406, 3, 983, 491, 0, 1406, 1407, 5, 95, 0, 0, 1407, 1408, 3, 991, 495, 0, 1408, 1409, 3, 985, 492, 0, 1409, 1410, 5, 95, 0, 0, 1410, 1411, 3, 1001, 500, 0, 1411, 1412, 3, 1003, 501, 0, 1412, 1413, 5, 95, 0, 0, 1413, 1414, 3, 1009, 504, 0, 1414, 1415, 3, 983, 491, 0, 1415, 1416, 3, 985, 492, 0, 1416, 1417, 3, 983, 491, 0, 1417, 1418, 3, 1009, 504, 0, 1418, 1419, 3, 983, 491, 0, 1419, 1420, 3, 1001, 500, 0, 1420, 1421, 3, 979, 489, 0, 1421, 1422, 3, 983, 491, 0, 1422, 1423, 3, 1011, 505, 0, 1423, 1446, 1, 0, 0, 0, 1424, 1425, 3, 981, 490, 0, 1425, 1426, 3, 983, 491, 0, 1426, 1427, 3, 997, 498, 0, 1427, 1428, 3, 983, 491, 0, 1428, 1429, 3, 1013, 506, 0, 1429, 1430, 3, 983, 491, 0, 1430, 1431, 3, 991, 495, 0, 1431, 1432, 3, 985, 492, 0, 1432, 1433, 3, 1001, 500, 0, 1433, 1434, 3, 1003, 501, 0, 1434, 1435, 3, 1009, 504, 0, 1435, 1436, 3, 983, 491, 0, 1436, 1437, 3, 985, 492, 0, 1437, 1438, 3, 983, 491, 0, 1438, 1439, 3, 1009, 504, 0, 1439, 1440, 3, 983, 491, 0, 1440, 1441, 3, 1001, 500, 0, 1441, 1442, 3, 979, 489, 0, 1442, 1443, 3, 983, 491, 0, 1443, 1444, 3, 1011, 505, 0, 1444, 1446, 1, 0, 0, 0, 1445, 1364, 1, 0, 0, 0, 1445, 1400, 1, 0, 0, 0, 1445, 1424, 1, 0, 0, 0, 1446, 32, 1, 0, 0, 0, 1447, 1448, 3, 979, 489, 0, 1448, 1449, 3, 1009, 504, 0, 1449, 1450, 3, 983, 491, 0, 1450, 1451, 3, 975, 487, 0, 1451, 1452, 3, 1013, 506, 0, 1452, 1453, 3, 983, 491, 0, 1453, 34, 1, 0, 0, 0, 1454, 1455, 3, 975, 487, 0, 1455, 1456, 3, 997, 498, 0, 1456, 1457, 3, 1013, 506, 0, 1457, 1458, 3, 983, 491, 0, 1458, 1459, 3, 1009, 504, 0, 1459, 36, 1, 0, 0, 0, 1460, 1461, 3, 981, 490, 0, 1461, 1462, 3, 1009, 504, 0, 1462, 1463, 3, 1003, 501, 0, 1463, 1464, 3, 1005, 502, 0, 1464, 38, 1, 0, 0, 0, 1465, 1466, 3, 1009, 504, 0, 1466, 1467, 3, 983, 491, 0, 1467, 1468, 3, 1001, 500, 0, 1468, 1469, 3, 975, 487, 0, 1469, 1470, 3, 999, 499, 0, 1470, 1471, 3, 983, 491, 0, 1471, 40, 1, 0, 0, 0, 1472, 1473, 3, 999, 499, 0, 1473, 1474, 3, 1003, 501, 0, 1474, 1475, 3, 1017, 508, 0, 1475, 1476, 3, 983, 491, 0, 1476, 42, 1, 0, 0, 0, 1477, 1478, 3, 999, 499, 0, 1478, 1479, 3, 1003, 501, 0, 1479, 1480, 3, 981, 490, 0, 1480, 1481, 3, 991, 495, 0, 1481, 1482, 3, 985, 492, 0, 1482, 1483, 3, 1023, 511, 0, 1483, 44, 1, 0, 0, 0, 1484, 1485, 3, 983, 491, 0, 1485, 1486, 3, 1001, 500, 0, 1486, 1487, 3, 1013, 506, 0, 1487, 1488, 3, 991, 495, 0, 1488, 1489, 3, 1013, 506, 0, 1489, 1490, 3, 1023, 511, 0, 1490, 46, 1, 0, 0, 0, 1491, 1492, 3, 1005, 502, 0, 1492, 1493, 3, 983, 491, 0, 1493, 1494, 3, 1009, 504, 0, 1494, 1495, 3, 1011, 505, 0, 1495, 1496, 3, 991, 495, 0, 1496, 1497, 3, 1011, 505, 0, 1497, 1498, 3, 1013, 506, 0, 1498, 1499, 3, 983, 491, 0, 1499, 1500, 3, 1001, 500, 0, 1500, 1501, 3, 1013, 506, 0, 1501, 48, 1, 0, 0, 0, 1502, 1503, 3, 1017, 508, 0, 1503, 1504, 3, 991, 495, 0, 1504, 1505, 3, 983, 491, 0, 1505, 1506, 3, 1019, 509, 0, 1506, 50, 1, 0, 0, 0, 1507, 1508, 3, 983, 491, 0, 1508, 1509, 3, 1021, 510, 0, 1509, 1510, 3, 1013, 506, 0, 1510, 1511, 3, 983, 491, 0, 1511, 1512, 3, 1009, 504, 0, 1512, 1513, 3, 1001, 500, 0, 1513, 1514, 3, 975, 487, 0, 1514, 1515, 3, 997, 498, 0, 1515, 52, 1, 0, 0, 0, 1516, 1517, 3, 975, 487, 0, 1517, 1518, 3, 1011, 505, 0, 1518, 1519, 3, 1011, 505, 0, 1519, 1520, 3, 1003, 501, 0, 1520, 1521, 3, 979, 489, 0, 1521, 1522, 3, 991, 495, 0, 1522, 1523, 3, 975, 487, 0, 1523, 1524, 3, 1013, 506, 0, 1524, 1525, 3, 991, 495, 0, 1525, 1526, 3, 1003, 501, 0, 1526, 1527, 3, 1001, 500, 0, 1527, 54, 1, 0, 0, 0, 1528, 1529, 3, 983, 491, 0, 1529, 1530, 3, 1001, 500, 0, 1530, 1531, 3, 1015, 507, 0, 1531, 1532, 3, 999, 499, 0, 1532, 1533, 3, 983, 491, 0, 1533, 1534, 3, 1009, 504, 0, 1534, 1535, 3, 975, 487, 0, 1535, 1536, 3, 1013, 506, 0, 1536, 1537, 3, 991, 495, 0, 1537, 1538, 3, 1003, 501, 0, 1538, 1539, 3, 1001, 500, 0, 1539, 56, 1, 0, 0, 0, 1540, 1541, 3, 999, 499, 0, 1541, 1542, 3, 1003, 501, 0, 1542, 1543, 3, 981, 490, 0, 1543, 1544, 3, 1015, 507, 0, 1544, 1545, 3, 997, 498, 0, 1545, 1546, 3, 983, 491, 0, 1546, 58, 1, 0, 0, 0, 1547, 1548, 3, 999, 499, 0, 1548, 1549, 3, 991, 495, 0, 1549, 1550, 3, 979, 489, 0, 1550, 1551, 3, 1009, 504, 0, 1551, 1552, 3, 1003, 501, 0, 1552, 1553, 3, 985, 492, 0, 1553, 1554, 3, 997, 498, 0, 1554, 1555, 3, 1003, 501, 0, 1555, 1556, 3, 1019, 509, 0, 1556, 60, 1, 0, 0, 0, 1557, 1558, 3, 1001, 500, 0, 1558, 1559, 3, 975, 487, 0, 1559, 1560, 3, 1001, 500, 0, 1560, 1561, 3, 1003, 501, 0, 1561, 1562, 3, 985, 492, 0, 1562, 1563, 3, 997, 498, 0, 1563, 1564, 3, 1003, 501, 0, 1564, 1565, 3, 1019, 509, 0, 1565, 62, 1, 0, 0, 0, 1566, 1567, 3, 1019, 509, 0, 1567, 1568, 3, 1003, 501, 0, 1568, 1569, 3, 1009, 504, 0, 1569, 1570, 3, 995, 497, 0, 1570, 1571, 3, 985, 492, 0, 1571, 1572, 3, 997, 498, 0, 1572, 1573, 3, 1003, 501, 0, 1573, 1574, 3, 1019, 509, 0, 1574, 64, 1, 0, 0, 0, 1575, 1576, 3, 1005, 502, 0, 1576, 1577, 3, 975, 487, 0, 1577, 1578, 3, 987, 493, 0, 1578, 1579, 3, 983, 491, 0, 1579, 66, 1, 0, 0, 0, 1580, 1581, 3, 1011, 505, 0, 1581, 1582, 3, 1001, 500, 0, 1582, 1583, 3, 991, 495, 0, 1583, 1584, 3, 1005, 502, 0, 1584, 1585, 3, 1005, 502, 0, 1585, 1586, 3, 983, 491, 0, 1586, 1587, 3, 1013, 506, 0, 1587, 68, 1, 0, 0, 0, 1588, 1589, 3, 997, 498, 0, 1589, 1590, 3, 975, 487, 0, 1590, 1591, 3, 1023, 511, 0, 1591, 1592, 3, 1003, 501, 0, 1592, 1593, 3, 1015, 507, 0, 1593, 1594, 3, 1013, 506, 0, 1594, 70, 1, 0, 0, 0, 1595, 1596, 3, 1001, 500, 0, 1596, 1597, 3, 1003, 501, 0, 1597, 1598, 3, 1013, 506, 0, 1598, 1599, 3, 983, 491, 0, 1599, 1600, 3, 977, 488, 0, 1600, 1601, 3, 1003, 501, 0, 1601, 1602, 3, 1003, 501, 0, 1602, 1603, 3, 995, 497, 0, 1603, 72, 1, 0, 0, 0, 1604, 1605, 3, 979, 489, 0, 1605, 1606, 3, 1003, 501, 0, 1606, 1607, 3, 1001, 500, 0, 1607, 1608, 3, 1011, 505, 0, 1608, 1609, 3, 1013, 506, 0, 1609, 1610, 3, 975, 487, 0, 1610, 1611, 3, 1001, 500, 0, 1611, 1612, 3, 1013, 506, 0, 1612, 74, 1, 0, 0, 0, 1613, 1614, 3, 975, 487, 0, 1614, 1615, 3, 1013, 506, 0, 1615, 1616, 3, 1013, 506, 0, 1616, 1617, 3, 1009, 504, 0, 1617, 1618, 3, 991, 495, 0, 1618, 1619, 3, 977, 488, 0, 1619, 1620, 3, 1015, 507, 0, 1620, 1621, 3, 1013, 506, 0, 1621, 1622, 3, 983, 491, 0, 1622, 76, 1, 0, 0, 0, 1623, 1624, 3, 979, 489, 0, 1624, 1625, 3, 1003, 501, 0, 1625, 1626, 3, 997, 498, 0, 1626, 1627, 3, 1015, 507, 0, 1627, 1628, 3, 999, 499, 0, 1628, 1629, 3, 1001, 500, 0, 1629, 78, 1, 0, 0, 0, 1630, 1631, 3, 979, 489, 0, 1631, 1632, 3, 1003, 501, 0, 1632, 1633, 3, 997, 498, 0, 1633, 1634, 3, 1015, 507, 0, 1634, 1635, 3, 999, 499, 0, 1635, 1636, 3, 1001, 500, 0, 1636, 1637, 3, 1011, 505, 0, 1637, 80, 1, 0, 0, 0, 1638, 1639, 3, 991, 495, 0, 1639, 1640, 3, 1001, 500, 0, 1640, 1641, 3, 981, 490, 0, 1641, 1642, 3, 983, 491, 0, 1642, 1643, 3, 1021, 510, 0, 1643, 82, 1, 0, 0, 0, 1644, 1645, 3, 1003, 501, 0, 1645, 1646, 3, 1019, 509, 0, 1646, 1647, 3, 1001, 500, 0, 1647, 1648, 3, 983, 491, 0, 1648, 1649, 3, 1009, 504, 0, 1649, 84, 1, 0, 0, 0, 1650, 1651, 3, 1009, 504, 0, 1651, 1652, 3, 983, 491, 0, 1652, 1653, 3, 985, 492, 0, 1653, 1654, 3, 983, 491, 0, 1654, 1655, 3, 1009, 504, 0, 1655, 1656, 3, 983, 491, 0, 1656, 1657, 3, 1001, 500, 0, 1657, 1658, 3, 979, 489, 0, 1658, 1659, 3, 983, 491, 0, 1659, 86, 1, 0, 0, 0, 1660, 1661, 3, 987, 493, 0, 1661, 1662, 3, 983, 491, 0, 1662, 1663, 3, 1001, 500, 0, 1663, 1664, 3, 983, 491, 0, 1664, 1665, 3, 1009, 504, 0, 1665, 1666, 3, 975, 487, 0, 1666, 1667, 3, 997, 498, 0, 1667, 1668, 3, 991, 495, 0, 1668, 1669, 3, 1025, 512, 0, 1669, 1670, 3, 975, 487, 0, 1670, 1671, 3, 1013, 506, 0, 1671, 1672, 3, 991, 495, 0, 1672, 1673, 3, 1003, 501, 0, 1673, 1674, 3, 1001, 500, 0, 1674, 88, 1, 0, 0, 0, 1675, 1676, 3, 983, 491, 0, 1676, 1677, 3, 1021, 510, 0, 1677, 1678, 3, 1013, 506, 0, 1678, 1679, 3, 983, 491, 0, 1679, 1680, 3, 1001, 500, 0, 1680, 1681, 3, 981, 490, 0, 1681, 1682, 3, 1011, 505, 0, 1682, 90, 1, 0, 0, 0, 1683, 1684, 3, 975, 487, 0, 1684, 1685, 3, 981, 490, 0, 1685, 1686, 3, 981, 490, 0, 1686, 92, 1, 0, 0, 0, 1687, 1688, 3, 1011, 505, 0, 1688, 1689, 3, 983, 491, 0, 1689, 1690, 3, 1013, 506, 0, 1690, 94, 1, 0, 0, 0, 1691, 1692, 3, 1005, 502, 0, 1692, 1693, 3, 1003, 501, 0, 1693, 1694, 3, 1011, 505, 0, 1694, 1695, 3, 991, 495, 0, 1695, 1696, 3, 1013, 506, 0, 1696, 1697, 3, 991, 495, 0, 1697, 1698, 3, 1003, 501, 0, 1698, 1699, 3, 1001, 500, 0, 1699, 96, 1, 0, 0, 0, 1700, 1701, 3, 981, 490, 0, 1701, 1702, 3, 1003, 501, 0, 1702, 1703, 3, 979, 489, 0, 1703, 1704, 3, 1015, 507, 0, 1704, 1705, 3, 999, 499, 0, 1705, 1706, 3, 983, 491, 0, 1706, 1707, 3, 1001, 500, 0, 1707, 1708, 3, 1013, 506, 0, 1708, 1709, 3, 975, 487, 0, 1709, 1710, 3, 1013, 506, 0, 1710, 1711, 3, 991, 495, 0, 1711, 1712, 3, 1003, 501, 0, 1712, 1713, 3, 1001, 500, 0, 1713, 98, 1, 0, 0, 0, 1714, 1715, 3, 1011, 505, 0, 1715, 1716, 3, 1013, 506, 0, 1716, 1717, 3, 1003, 501, 0, 1717, 1718, 3, 1009, 504, 0, 1718, 1719, 3, 975, 487, 0, 1719, 1720, 3, 987, 493, 0, 1720, 1721, 3, 983, 491, 0, 1721, 100, 1, 0, 0, 0, 1722, 1723, 3, 1013, 506, 0, 1723, 1724, 3, 975, 487, 0, 1724, 1725, 3, 977, 488, 0, 1725, 1726, 3, 997, 498, 0, 1726, 1727, 3, 983, 491, 0, 1727, 102, 1, 0, 0, 0, 1728, 1729, 3, 981, 490, 0, 1729, 1730, 3, 983, 491, 0, 1730, 1731, 3, 997, 498, 0, 1731, 1732, 3, 983, 491, 0, 1732, 1733, 3, 1013, 506, 0, 1733, 1735, 3, 983, 491, 0, 1734, 1736, 5, 95, 0, 0, 1735, 1734, 1, 0, 0, 0, 1735, 1736, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 1738, 3, 977, 488, 0, 1738, 1739, 3, 983, 491, 0, 1739, 1740, 3, 989, 494, 0, 1740, 1741, 3, 975, 487, 0, 1741, 1742, 3, 1017, 508, 0, 1742, 1743, 3, 991, 495, 0, 1743, 1744, 3, 1003, 501, 0, 1744, 1745, 3, 1009, 504, 0, 1745, 104, 1, 0, 0, 0, 1746, 1747, 3, 979, 489, 0, 1747, 1748, 3, 975, 487, 0, 1748, 1749, 3, 1011, 505, 0, 1749, 1750, 3, 979, 489, 0, 1750, 1751, 3, 975, 487, 0, 1751, 1752, 3, 981, 490, 0, 1752, 1753, 3, 983, 491, 0, 1753, 106, 1, 0, 0, 0, 1754, 1755, 3, 1005, 502, 0, 1755, 1756, 3, 1009, 504, 0, 1756, 1757, 3, 983, 491, 0, 1757, 1758, 3, 1017, 508, 0, 1758, 1759, 3, 983, 491, 0, 1759, 1760, 3, 1001, 500, 0, 1760, 1761, 3, 1013, 506, 0, 1761, 108, 1, 0, 0, 0, 1762, 1763, 3, 979, 489, 0, 1763, 1764, 3, 1003, 501, 0, 1764, 1765, 3, 1001, 500, 0, 1765, 1766, 3, 1001, 500, 0, 1766, 1767, 3, 983, 491, 0, 1767, 1768, 3, 979, 489, 0, 1768, 1769, 3, 1013, 506, 0, 1769, 110, 1, 0, 0, 0, 1770, 1771, 3, 981, 490, 0, 1771, 1772, 3, 991, 495, 0, 1772, 1773, 3, 1011, 505, 0, 1773, 1774, 3, 979, 489, 0, 1774, 1775, 3, 1003, 501, 0, 1775, 1776, 3, 1001, 500, 0, 1776, 1777, 3, 1001, 500, 0, 1777, 1778, 3, 983, 491, 0, 1778, 1779, 3, 979, 489, 0, 1779, 1780, 3, 1013, 506, 0, 1780, 112, 1, 0, 0, 0, 1781, 1782, 3, 997, 498, 0, 1782, 1783, 3, 1003, 501, 0, 1783, 1784, 3, 979, 489, 0, 1784, 1785, 3, 975, 487, 0, 1785, 1786, 3, 997, 498, 0, 1786, 114, 1, 0, 0, 0, 1787, 1788, 3, 1005, 502, 0, 1788, 1789, 3, 1009, 504, 0, 1789, 1790, 3, 1003, 501, 0, 1790, 1791, 3, 993, 496, 0, 1791, 1792, 3, 983, 491, 0, 1792, 1793, 3, 979, 489, 0, 1793, 1794, 3, 1013, 506, 0, 1794, 116, 1, 0, 0, 0, 1795, 1796, 3, 1009, 504, 0, 1796, 1797, 3, 1015, 507, 0, 1797, 1798, 3, 1001, 500, 0, 1798, 1799, 3, 1013, 506, 0, 1799, 1800, 3, 991, 495, 0, 1800, 1801, 3, 999, 499, 0, 1801, 1802, 3, 983, 491, 0, 1802, 118, 1, 0, 0, 0, 1803, 1804, 3, 977, 488, 0, 1804, 1805, 3, 1009, 504, 0, 1805, 1806, 3, 975, 487, 0, 1806, 1807, 3, 1001, 500, 0, 1807, 1808, 3, 979, 489, 0, 1808, 1809, 3, 989, 494, 0, 1809, 120, 1, 0, 0, 0, 1810, 1811, 3, 1013, 506, 0, 1811, 1812, 3, 1003, 501, 0, 1812, 1813, 3, 995, 497, 0, 1813, 1814, 3, 983, 491, 0, 1814, 1815, 3, 1001, 500, 0, 1815, 122, 1, 0, 0, 0, 1816, 1817, 3, 989, 494, 0, 1817, 1818, 3, 1003, 501, 0, 1818, 1819, 3, 1011, 505, 0, 1819, 1820, 3, 1013, 506, 0, 1820, 124, 1, 0, 0, 0, 1821, 1822, 3, 1005, 502, 0, 1822, 1823, 3, 1003, 501, 0, 1823, 1824, 3, 1009, 504, 0, 1824, 1825, 3, 1013, 506, 0, 1825, 126, 1, 0, 0, 0, 1826, 1827, 3, 1011, 505, 0, 1827, 1828, 3, 989, 494, 0, 1828, 1829, 3, 1003, 501, 0, 1829, 1830, 3, 1019, 509, 0, 1830, 128, 1, 0, 0, 0, 1831, 1832, 3, 981, 490, 0, 1832, 1833, 3, 983, 491, 0, 1833, 1834, 3, 1011, 505, 0, 1834, 1835, 3, 979, 489, 0, 1835, 1836, 3, 1009, 504, 0, 1836, 1837, 3, 991, 495, 0, 1837, 1838, 3, 977, 488, 0, 1838, 1839, 3, 983, 491, 0, 1839, 130, 1, 0, 0, 0, 1840, 1841, 3, 1015, 507, 0, 1841, 1842, 3, 1011, 505, 0, 1842, 1843, 3, 983, 491, 0, 1843, 132, 1, 0, 0, 0, 1844, 1845, 3, 991, 495, 0, 1845, 1846, 3, 1001, 500, 0, 1846, 1847, 3, 1013, 506, 0, 1847, 1848, 3, 1009, 504, 0, 1848, 1849, 3, 1003, 501, 0, 1849, 1850, 3, 1011, 505, 0, 1850, 1851, 3, 1005, 502, 0, 1851, 1852, 3, 983, 491, 0, 1852, 1853, 3, 979, 489, 0, 1853, 1854, 3, 1013, 506, 0, 1854, 134, 1, 0, 0, 0, 1855, 1856, 3, 981, 490, 0, 1856, 1857, 3, 983, 491, 0, 1857, 1858, 3, 977, 488, 0, 1858, 1859, 3, 1015, 507, 0, 1859, 1860, 3, 987, 493, 0, 1860, 136, 1, 0, 0, 0, 1861, 1862, 3, 1011, 505, 0, 1862, 1863, 3, 983, 491, 0, 1863, 1864, 3, 997, 498, 0, 1864, 1865, 3, 983, 491, 0, 1865, 1866, 3, 979, 489, 0, 1866, 1867, 3, 1013, 506, 0, 1867, 138, 1, 0, 0, 0, 1868, 1869, 3, 985, 492, 0, 1869, 1870, 3, 1009, 504, 0, 1870, 1871, 3, 1003, 501, 0, 1871, 1872, 3, 999, 499, 0, 1872, 140, 1, 0, 0, 0, 1873, 1874, 3, 1019, 509, 0, 1874, 1875, 3, 989, 494, 0, 1875, 1876, 3, 983, 491, 0, 1876, 1877, 3, 1009, 504, 0, 1877, 1878, 3, 983, 491, 0, 1878, 142, 1, 0, 0, 0, 1879, 1880, 3, 989, 494, 0, 1880, 1881, 3, 975, 487, 0, 1881, 1882, 3, 1017, 508, 0, 1882, 1883, 3, 991, 495, 0, 1883, 1884, 3, 1001, 500, 0, 1884, 1885, 3, 987, 493, 0, 1885, 144, 1, 0, 0, 0, 1886, 1887, 3, 1003, 501, 0, 1887, 1888, 3, 985, 492, 0, 1888, 1889, 3, 985, 492, 0, 1889, 1890, 3, 1011, 505, 0, 1890, 1891, 3, 983, 491, 0, 1891, 1892, 3, 1013, 506, 0, 1892, 146, 1, 0, 0, 0, 1893, 1894, 3, 997, 498, 0, 1894, 1895, 3, 991, 495, 0, 1895, 1896, 3, 999, 499, 0, 1896, 1897, 3, 991, 495, 0, 1897, 1898, 3, 1013, 506, 0, 1898, 148, 1, 0, 0, 0, 1899, 1900, 3, 975, 487, 0, 1900, 1901, 3, 1011, 505, 0, 1901, 150, 1, 0, 0, 0, 1902, 1903, 3, 1009, 504, 0, 1903, 1904, 3, 983, 491, 0, 1904, 1905, 3, 1013, 506, 0, 1905, 1906, 3, 1015, 507, 0, 1906, 1907, 3, 1009, 504, 0, 1907, 1908, 3, 1001, 500, 0, 1908, 1909, 3, 1011, 505, 0, 1909, 152, 1, 0, 0, 0, 1910, 1911, 3, 1009, 504, 0, 1911, 1912, 3, 983, 491, 0, 1912, 1913, 3, 1013, 506, 0, 1913, 1914, 3, 1015, 507, 0, 1914, 1915, 3, 1009, 504, 0, 1915, 1916, 3, 1001, 500, 0, 1916, 1917, 3, 991, 495, 0, 1917, 1918, 3, 1001, 500, 0, 1918, 1919, 3, 987, 493, 0, 1919, 154, 1, 0, 0, 0, 1920, 1921, 3, 979, 489, 0, 1921, 1922, 3, 975, 487, 0, 1922, 1923, 3, 1011, 505, 0, 1923, 1924, 3, 983, 491, 0, 1924, 156, 1, 0, 0, 0, 1925, 1926, 3, 1019, 509, 0, 1926, 1927, 3, 989, 494, 0, 1927, 1928, 3, 983, 491, 0, 1928, 1929, 3, 1001, 500, 0, 1929, 158, 1, 0, 0, 0, 1930, 1931, 3, 1013, 506, 0, 1931, 1932, 3, 989, 494, 0, 1932, 1933, 3, 983, 491, 0, 1933, 1934, 3, 1001, 500, 0, 1934, 160, 1, 0, 0, 0, 1935, 1936, 3, 983, 491, 0, 1936, 1937, 3, 997, 498, 0, 1937, 1938, 3, 1011, 505, 0, 1938, 1939, 3, 983, 491, 0, 1939, 162, 1, 0, 0, 0, 1940, 1941, 3, 983, 491, 0, 1941, 1942, 3, 1001, 500, 0, 1942, 1943, 3, 981, 490, 0, 1943, 164, 1, 0, 0, 0, 1944, 1945, 3, 981, 490, 0, 1945, 1946, 3, 991, 495, 0, 1946, 1947, 3, 1011, 505, 0, 1947, 1948, 3, 1013, 506, 0, 1948, 1949, 3, 991, 495, 0, 1949, 1950, 3, 1001, 500, 0, 1950, 1951, 3, 979, 489, 0, 1951, 1952, 3, 1013, 506, 0, 1952, 166, 1, 0, 0, 0, 1953, 1954, 3, 975, 487, 0, 1954, 1955, 3, 997, 498, 0, 1955, 1956, 3, 997, 498, 0, 1956, 168, 1, 0, 0, 0, 1957, 1958, 3, 993, 496, 0, 1958, 1959, 3, 1003, 501, 0, 1959, 1960, 3, 991, 495, 0, 1960, 1961, 3, 1001, 500, 0, 1961, 170, 1, 0, 0, 0, 1962, 1963, 3, 997, 498, 0, 1963, 1964, 3, 983, 491, 0, 1964, 1965, 3, 985, 492, 0, 1965, 1966, 3, 1013, 506, 0, 1966, 172, 1, 0, 0, 0, 1967, 1968, 3, 1009, 504, 0, 1968, 1969, 3, 991, 495, 0, 1969, 1970, 3, 987, 493, 0, 1970, 1971, 3, 989, 494, 0, 1971, 1972, 3, 1013, 506, 0, 1972, 174, 1, 0, 0, 0, 1973, 1974, 3, 991, 495, 0, 1974, 1975, 3, 1001, 500, 0, 1975, 1976, 3, 1001, 500, 0, 1976, 1977, 3, 983, 491, 0, 1977, 1978, 3, 1009, 504, 0, 1978, 176, 1, 0, 0, 0, 1979, 1980, 3, 1003, 501, 0, 1980, 1981, 3, 1015, 507, 0, 1981, 1982, 3, 1013, 506, 0, 1982, 1983, 3, 983, 491, 0, 1983, 1984, 3, 1009, 504, 0, 1984, 178, 1, 0, 0, 0, 1985, 1986, 3, 985, 492, 0, 1986, 1987, 3, 1015, 507, 0, 1987, 1988, 3, 997, 498, 0, 1988, 1989, 3, 997, 498, 0, 1989, 180, 1, 0, 0, 0, 1990, 1991, 3, 979, 489, 0, 1991, 1992, 3, 1009, 504, 0, 1992, 1993, 3, 1003, 501, 0, 1993, 1994, 3, 1011, 505, 0, 1994, 1995, 3, 1011, 505, 0, 1995, 182, 1, 0, 0, 0, 1996, 1997, 3, 1003, 501, 0, 1997, 1998, 3, 1001, 500, 0, 1998, 184, 1, 0, 0, 0, 1999, 2000, 3, 975, 487, 0, 2000, 2001, 3, 1011, 505, 0, 2001, 2002, 3, 979, 489, 0, 2002, 186, 1, 0, 0, 0, 2003, 2004, 3, 981, 490, 0, 2004, 2005, 3, 983, 491, 0, 2005, 2006, 3, 1011, 505, 0, 2006, 2007, 3, 979, 489, 0, 2007, 188, 1, 0, 0, 0, 2008, 2009, 3, 977, 488, 0, 2009, 2010, 3, 983, 491, 0, 2010, 2011, 3, 987, 493, 0, 2011, 2012, 3, 991, 495, 0, 2012, 2013, 3, 1001, 500, 0, 2013, 190, 1, 0, 0, 0, 2014, 2015, 3, 981, 490, 0, 2015, 2016, 3, 983, 491, 0, 2016, 2017, 3, 979, 489, 0, 2017, 2018, 3, 997, 498, 0, 2018, 2019, 3, 975, 487, 0, 2019, 2020, 3, 1009, 504, 0, 2020, 2021, 3, 983, 491, 0, 2021, 192, 1, 0, 0, 0, 2022, 2023, 3, 979, 489, 0, 2023, 2024, 3, 989, 494, 0, 2024, 2025, 3, 975, 487, 0, 2025, 2026, 3, 1001, 500, 0, 2026, 2027, 3, 987, 493, 0, 2027, 2028, 3, 983, 491, 0, 2028, 194, 1, 0, 0, 0, 2029, 2030, 3, 1009, 504, 0, 2030, 2031, 3, 983, 491, 0, 2031, 2032, 3, 1013, 506, 0, 2032, 2033, 3, 1009, 504, 0, 2033, 2034, 3, 991, 495, 0, 2034, 2035, 3, 983, 491, 0, 2035, 2036, 3, 1017, 508, 0, 2036, 2037, 3, 983, 491, 0, 2037, 196, 1, 0, 0, 0, 2038, 2039, 3, 981, 490, 0, 2039, 2040, 3, 983, 491, 0, 2040, 2041, 3, 997, 498, 0, 2041, 2042, 3, 983, 491, 0, 2042, 2043, 3, 1013, 506, 0, 2043, 2044, 3, 983, 491, 0, 2044, 198, 1, 0, 0, 0, 2045, 2046, 3, 979, 489, 0, 2046, 2047, 3, 1003, 501, 0, 2047, 2048, 3, 999, 499, 0, 2048, 2049, 3, 999, 499, 0, 2049, 2050, 3, 991, 495, 0, 2050, 2051, 3, 1013, 506, 0, 2051, 200, 1, 0, 0, 0, 2052, 2053, 3, 1009, 504, 0, 2053, 2054, 3, 1003, 501, 0, 2054, 2055, 3, 997, 498, 0, 2055, 2056, 3, 997, 498, 0, 2056, 2057, 3, 977, 488, 0, 2057, 2058, 3, 975, 487, 0, 2058, 2059, 3, 979, 489, 0, 2059, 2060, 3, 995, 497, 0, 2060, 202, 1, 0, 0, 0, 2061, 2062, 3, 997, 498, 0, 2062, 2063, 3, 1003, 501, 0, 2063, 2064, 3, 1003, 501, 0, 2064, 2065, 3, 1005, 502, 0, 2065, 204, 1, 0, 0, 0, 2066, 2067, 3, 1019, 509, 0, 2067, 2068, 3, 989, 494, 0, 2068, 2069, 3, 991, 495, 0, 2069, 2070, 3, 997, 498, 0, 2070, 2071, 3, 983, 491, 0, 2071, 206, 1, 0, 0, 0, 2072, 2073, 3, 991, 495, 0, 2073, 2074, 3, 985, 492, 0, 2074, 208, 1, 0, 0, 0, 2075, 2076, 3, 983, 491, 0, 2076, 2077, 3, 997, 498, 0, 2077, 2078, 3, 1011, 505, 0, 2078, 2079, 3, 991, 495, 0, 2079, 2080, 3, 985, 492, 0, 2080, 210, 1, 0, 0, 0, 2081, 2082, 3, 983, 491, 0, 2082, 2083, 3, 997, 498, 0, 2083, 2084, 3, 1011, 505, 0, 2084, 2085, 3, 983, 491, 0, 2085, 2086, 3, 991, 495, 0, 2086, 2087, 3, 985, 492, 0, 2087, 212, 1, 0, 0, 0, 2088, 2089, 3, 979, 489, 0, 2089, 2090, 3, 1003, 501, 0, 2090, 2091, 3, 1001, 500, 0, 2091, 2092, 3, 1013, 506, 0, 2092, 2093, 3, 991, 495, 0, 2093, 2094, 3, 1001, 500, 0, 2094, 2095, 3, 1015, 507, 0, 2095, 2096, 3, 983, 491, 0, 2096, 214, 1, 0, 0, 0, 2097, 2098, 3, 977, 488, 0, 2098, 2099, 3, 1009, 504, 0, 2099, 2100, 3, 983, 491, 0, 2100, 2101, 3, 975, 487, 0, 2101, 2102, 3, 995, 497, 0, 2102, 216, 1, 0, 0, 0, 2103, 2104, 3, 1009, 504, 0, 2104, 2105, 3, 983, 491, 0, 2105, 2106, 3, 1013, 506, 0, 2106, 2107, 3, 1015, 507, 0, 2107, 2108, 3, 1009, 504, 0, 2108, 2109, 3, 1001, 500, 0, 2109, 218, 1, 0, 0, 0, 2110, 2111, 3, 1013, 506, 0, 2111, 2112, 3, 989, 494, 0, 2112, 2113, 3, 1009, 504, 0, 2113, 2114, 3, 1003, 501, 0, 2114, 2115, 3, 1019, 509, 0, 2115, 220, 1, 0, 0, 0, 2116, 2117, 3, 997, 498, 0, 2117, 2118, 3, 1003, 501, 0, 2118, 2119, 3, 987, 493, 0, 2119, 222, 1, 0, 0, 0, 2120, 2121, 3, 979, 489, 0, 2121, 2122, 3, 975, 487, 0, 2122, 2123, 3, 997, 498, 0, 2123, 2124, 3, 997, 498, 0, 2124, 224, 1, 0, 0, 0, 2125, 2126, 3, 993, 496, 0, 2126, 2127, 3, 975, 487, 0, 2127, 2128, 3, 1017, 508, 0, 2128, 2129, 3, 975, 487, 0, 2129, 226, 1, 0, 0, 0, 2130, 2131, 3, 975, 487, 0, 2131, 2132, 3, 979, 489, 0, 2132, 2133, 3, 1013, 506, 0, 2133, 2134, 3, 991, 495, 0, 2134, 2135, 3, 1003, 501, 0, 2135, 2136, 3, 1001, 500, 0, 2136, 228, 1, 0, 0, 0, 2137, 2138, 3, 975, 487, 0, 2138, 2139, 3, 979, 489, 0, 2139, 2140, 3, 1013, 506, 0, 2140, 2141, 3, 991, 495, 0, 2141, 2142, 3, 1003, 501, 0, 2142, 2143, 3, 1001, 500, 0, 2143, 2144, 3, 1011, 505, 0, 2144, 230, 1, 0, 0, 0, 2145, 2146, 3, 979, 489, 0, 2146, 2147, 3, 997, 498, 0, 2147, 2148, 3, 1003, 501, 0, 2148, 2149, 3, 1011, 505, 0, 2149, 2150, 3, 983, 491, 0, 2150, 232, 1, 0, 0, 0, 2151, 2152, 3, 1001, 500, 0, 2152, 2153, 3, 1003, 501, 0, 2153, 2154, 3, 981, 490, 0, 2154, 2155, 3, 983, 491, 0, 2155, 234, 1, 0, 0, 0, 2156, 2157, 3, 983, 491, 0, 2157, 2158, 3, 1017, 508, 0, 2158, 2159, 3, 983, 491, 0, 2159, 2160, 3, 1001, 500, 0, 2160, 2161, 3, 1013, 506, 0, 2161, 2162, 3, 1011, 505, 0, 2162, 236, 1, 0, 0, 0, 2163, 2164, 3, 989, 494, 0, 2164, 2165, 3, 983, 491, 0, 2165, 2166, 3, 975, 487, 0, 2166, 2167, 3, 981, 490, 0, 2167, 238, 1, 0, 0, 0, 2168, 2169, 3, 1013, 506, 0, 2169, 2170, 3, 975, 487, 0, 2170, 2171, 3, 991, 495, 0, 2171, 2172, 3, 997, 498, 0, 2172, 240, 1, 0, 0, 0, 2173, 2174, 3, 985, 492, 0, 2174, 2175, 3, 991, 495, 0, 2175, 2176, 3, 1001, 500, 0, 2176, 2177, 3, 981, 490, 0, 2177, 242, 1, 0, 0, 0, 2178, 2179, 3, 1011, 505, 0, 2179, 2180, 3, 1003, 501, 0, 2180, 2181, 3, 1009, 504, 0, 2181, 2182, 3, 1013, 506, 0, 2182, 244, 1, 0, 0, 0, 2183, 2184, 3, 1015, 507, 0, 2184, 2185, 3, 1001, 500, 0, 2185, 2186, 3, 991, 495, 0, 2186, 2187, 3, 1003, 501, 0, 2187, 2188, 3, 1001, 500, 0, 2188, 246, 1, 0, 0, 0, 2189, 2190, 3, 991, 495, 0, 2190, 2191, 3, 1001, 500, 0, 2191, 2192, 3, 1013, 506, 0, 2192, 2193, 3, 983, 491, 0, 2193, 2194, 3, 1009, 504, 0, 2194, 2195, 3, 1011, 505, 0, 2195, 2196, 3, 983, 491, 0, 2196, 2197, 3, 979, 489, 0, 2197, 2198, 3, 1013, 506, 0, 2198, 248, 1, 0, 0, 0, 2199, 2200, 3, 1011, 505, 0, 2200, 2201, 3, 1015, 507, 0, 2201, 2202, 3, 977, 488, 0, 2202, 2203, 3, 1013, 506, 0, 2203, 2204, 3, 1009, 504, 0, 2204, 2205, 3, 975, 487, 0, 2205, 2206, 3, 979, 489, 0, 2206, 2207, 3, 1013, 506, 0, 2207, 250, 1, 0, 0, 0, 2208, 2209, 3, 979, 489, 0, 2209, 2210, 3, 1003, 501, 0, 2210, 2211, 3, 1001, 500, 0, 2211, 2212, 3, 1013, 506, 0, 2212, 2213, 3, 975, 487, 0, 2213, 2214, 3, 991, 495, 0, 2214, 2215, 3, 1001, 500, 0, 2215, 2216, 3, 1011, 505, 0, 2216, 252, 1, 0, 0, 0, 2217, 2218, 3, 975, 487, 0, 2218, 2219, 3, 1017, 508, 0, 2219, 2220, 3, 983, 491, 0, 2220, 2221, 3, 1009, 504, 0, 2221, 2222, 3, 975, 487, 0, 2222, 2223, 3, 987, 493, 0, 2223, 2224, 3, 983, 491, 0, 2224, 254, 1, 0, 0, 0, 2225, 2226, 3, 999, 499, 0, 2226, 2227, 3, 991, 495, 0, 2227, 2228, 3, 1001, 500, 0, 2228, 2229, 3, 991, 495, 0, 2229, 2230, 3, 999, 499, 0, 2230, 2231, 3, 1015, 507, 0, 2231, 2232, 3, 999, 499, 0, 2232, 256, 1, 0, 0, 0, 2233, 2234, 3, 999, 499, 0, 2234, 2235, 3, 975, 487, 0, 2235, 2236, 3, 1021, 510, 0, 2236, 2237, 3, 991, 495, 0, 2237, 2238, 3, 999, 499, 0, 2238, 2239, 3, 1015, 507, 0, 2239, 2240, 3, 999, 499, 0, 2240, 258, 1, 0, 0, 0, 2241, 2242, 3, 997, 498, 0, 2242, 2243, 3, 991, 495, 0, 2243, 2244, 3, 1011, 505, 0, 2244, 2245, 3, 1013, 506, 0, 2245, 260, 1, 0, 0, 0, 2246, 2247, 3, 1009, 504, 0, 2247, 2248, 3, 983, 491, 0, 2248, 2249, 3, 999, 499, 0, 2249, 2250, 3, 1003, 501, 0, 2250, 2251, 3, 1017, 508, 0, 2251, 2252, 3, 983, 491, 0, 2252, 262, 1, 0, 0, 0, 2253, 2254, 3, 983, 491, 0, 2254, 2255, 3, 1007, 503, 0, 2255, 2256, 3, 1015, 507, 0, 2256, 2257, 3, 975, 487, 0, 2257, 2258, 3, 997, 498, 0, 2258, 2259, 3, 1011, 505, 0, 2259, 264, 1, 0, 0, 0, 2260, 2261, 3, 991, 495, 0, 2261, 2262, 3, 1001, 500, 0, 2262, 2263, 3, 985, 492, 0, 2263, 2264, 3, 1003, 501, 0, 2264, 266, 1, 0, 0, 0, 2265, 2266, 3, 1019, 509, 0, 2266, 2267, 3, 975, 487, 0, 2267, 2268, 3, 1009, 504, 0, 2268, 2269, 3, 1001, 500, 0, 2269, 2270, 3, 991, 495, 0, 2270, 2271, 3, 1001, 500, 0, 2271, 2272, 3, 987, 493, 0, 2272, 268, 1, 0, 0, 0, 2273, 2274, 3, 1013, 506, 0, 2274, 2275, 3, 1009, 504, 0, 2275, 2276, 3, 975, 487, 0, 2276, 2277, 3, 979, 489, 0, 2277, 2278, 3, 983, 491, 0, 2278, 270, 1, 0, 0, 0, 2279, 2280, 3, 979, 489, 0, 2280, 2281, 3, 1009, 504, 0, 2281, 2282, 3, 991, 495, 0, 2282, 2283, 3, 1013, 506, 0, 2283, 2284, 3, 991, 495, 0, 2284, 2285, 3, 979, 489, 0, 2285, 2286, 3, 975, 487, 0, 2286, 2287, 3, 997, 498, 0, 2287, 272, 1, 0, 0, 0, 2288, 2289, 3, 1019, 509, 0, 2289, 2290, 3, 991, 495, 0, 2290, 2291, 3, 1013, 506, 0, 2291, 2292, 3, 989, 494, 0, 2292, 274, 1, 0, 0, 0, 2293, 2294, 3, 983, 491, 0, 2294, 2295, 3, 999, 499, 0, 2295, 2296, 3, 1005, 502, 0, 2296, 2297, 3, 1013, 506, 0, 2297, 2298, 3, 1023, 511, 0, 2298, 276, 1, 0, 0, 0, 2299, 2300, 3, 1003, 501, 0, 2300, 2301, 3, 977, 488, 0, 2301, 2302, 3, 993, 496, 0, 2302, 2303, 3, 983, 491, 0, 2303, 2304, 3, 979, 489, 0, 2304, 2305, 3, 1013, 506, 0, 2305, 278, 1, 0, 0, 0, 2306, 2307, 3, 1003, 501, 0, 2307, 2308, 3, 977, 488, 0, 2308, 2309, 3, 993, 496, 0, 2309, 2310, 3, 983, 491, 0, 2310, 2311, 3, 979, 489, 0, 2311, 2312, 3, 1013, 506, 0, 2312, 2313, 3, 1011, 505, 0, 2313, 280, 1, 0, 0, 0, 2314, 2315, 3, 1005, 502, 0, 2315, 2316, 3, 975, 487, 0, 2316, 2317, 3, 987, 493, 0, 2317, 2318, 3, 983, 491, 0, 2318, 2319, 3, 1011, 505, 0, 2319, 282, 1, 0, 0, 0, 2320, 2321, 3, 997, 498, 0, 2321, 2322, 3, 975, 487, 0, 2322, 2323, 3, 1023, 511, 0, 2323, 2324, 3, 1003, 501, 0, 2324, 2325, 3, 1015, 507, 0, 2325, 2326, 3, 1013, 506, 0, 2326, 2327, 3, 1011, 505, 0, 2327, 284, 1, 0, 0, 0, 2328, 2329, 3, 1011, 505, 0, 2329, 2330, 3, 1001, 500, 0, 2330, 2331, 3, 991, 495, 0, 2331, 2332, 3, 1005, 502, 0, 2332, 2333, 3, 1005, 502, 0, 2333, 2334, 3, 983, 491, 0, 2334, 2335, 3, 1013, 506, 0, 2335, 2336, 3, 1011, 505, 0, 2336, 286, 1, 0, 0, 0, 2337, 2338, 3, 1001, 500, 0, 2338, 2339, 3, 1003, 501, 0, 2339, 2340, 3, 1013, 506, 0, 2340, 2341, 3, 983, 491, 0, 2341, 2342, 3, 977, 488, 0, 2342, 2343, 3, 1003, 501, 0, 2343, 2344, 3, 1003, 501, 0, 2344, 2345, 3, 995, 497, 0, 2345, 2346, 3, 1011, 505, 0, 2346, 288, 1, 0, 0, 0, 2347, 2348, 3, 1005, 502, 0, 2348, 2349, 3, 997, 498, 0, 2349, 2350, 3, 975, 487, 0, 2350, 2351, 3, 979, 489, 0, 2351, 2352, 3, 983, 491, 0, 2352, 2353, 3, 989, 494, 0, 2353, 2354, 3, 1003, 501, 0, 2354, 2355, 3, 997, 498, 0, 2355, 2356, 3, 981, 490, 0, 2356, 2357, 3, 983, 491, 0, 2357, 2358, 3, 1009, 504, 0, 2358, 290, 1, 0, 0, 0, 2359, 2360, 3, 1011, 505, 0, 2360, 2361, 3, 1001, 500, 0, 2361, 2362, 3, 991, 495, 0, 2362, 2363, 3, 1005, 502, 0, 2363, 2364, 3, 1005, 502, 0, 2364, 2365, 3, 983, 491, 0, 2365, 2366, 3, 1013, 506, 0, 2366, 2367, 3, 979, 489, 0, 2367, 2368, 3, 975, 487, 0, 2368, 2369, 3, 997, 498, 0, 2369, 2370, 3, 997, 498, 0, 2370, 292, 1, 0, 0, 0, 2371, 2372, 3, 997, 498, 0, 2372, 2373, 3, 975, 487, 0, 2373, 2374, 3, 1023, 511, 0, 2374, 2375, 3, 1003, 501, 0, 2375, 2376, 3, 1015, 507, 0, 2376, 2377, 3, 1013, 506, 0, 2377, 2378, 3, 987, 493, 0, 2378, 2379, 3, 1009, 504, 0, 2379, 2380, 3, 991, 495, 0, 2380, 2381, 3, 981, 490, 0, 2381, 294, 1, 0, 0, 0, 2382, 2383, 3, 981, 490, 0, 2383, 2384, 3, 975, 487, 0, 2384, 2385, 3, 1013, 506, 0, 2385, 2386, 3, 975, 487, 0, 2386, 2387, 3, 987, 493, 0, 2387, 2388, 3, 1009, 504, 0, 2388, 2389, 3, 991, 495, 0, 2389, 2390, 3, 981, 490, 0, 2390, 296, 1, 0, 0, 0, 2391, 2392, 3, 981, 490, 0, 2392, 2393, 3, 975, 487, 0, 2393, 2394, 3, 1013, 506, 0, 2394, 2395, 3, 975, 487, 0, 2395, 2396, 3, 1017, 508, 0, 2396, 2397, 3, 991, 495, 0, 2397, 2398, 3, 983, 491, 0, 2398, 2399, 3, 1019, 509, 0, 2399, 298, 1, 0, 0, 0, 2400, 2401, 3, 997, 498, 0, 2401, 2402, 3, 991, 495, 0, 2402, 2403, 3, 1011, 505, 0, 2403, 2404, 3, 1013, 506, 0, 2404, 2405, 3, 1017, 508, 0, 2405, 2406, 3, 991, 495, 0, 2406, 2407, 3, 983, 491, 0, 2407, 2408, 3, 1019, 509, 0, 2408, 300, 1, 0, 0, 0, 2409, 2410, 3, 987, 493, 0, 2410, 2411, 3, 975, 487, 0, 2411, 2412, 3, 997, 498, 0, 2412, 2413, 3, 997, 498, 0, 2413, 2414, 3, 983, 491, 0, 2414, 2415, 3, 1009, 504, 0, 2415, 2416, 3, 1023, 511, 0, 2416, 302, 1, 0, 0, 0, 2417, 2418, 3, 979, 489, 0, 2418, 2419, 3, 1003, 501, 0, 2419, 2420, 3, 1001, 500, 0, 2420, 2421, 3, 1013, 506, 0, 2421, 2422, 3, 975, 487, 0, 2422, 2423, 3, 991, 495, 0, 2423, 2424, 3, 1001, 500, 0, 2424, 2425, 3, 983, 491, 0, 2425, 2426, 3, 1009, 504, 0, 2426, 304, 1, 0, 0, 0, 2427, 2428, 3, 1009, 504, 0, 2428, 2429, 3, 1003, 501, 0, 2429, 2430, 3, 1019, 509, 0, 2430, 306, 1, 0, 0, 0, 2431, 2432, 3, 991, 495, 0, 2432, 2433, 3, 1013, 506, 0, 2433, 2434, 3, 983, 491, 0, 2434, 2435, 3, 999, 499, 0, 2435, 308, 1, 0, 0, 0, 2436, 2437, 3, 979, 489, 0, 2437, 2438, 3, 1003, 501, 0, 2438, 2439, 3, 1001, 500, 0, 2439, 2440, 3, 1013, 506, 0, 2440, 2441, 3, 1009, 504, 0, 2441, 2442, 3, 1003, 501, 0, 2442, 2443, 3, 997, 498, 0, 2443, 2444, 3, 977, 488, 0, 2444, 2445, 3, 975, 487, 0, 2445, 2446, 3, 1009, 504, 0, 2446, 310, 1, 0, 0, 0, 2447, 2448, 3, 1011, 505, 0, 2448, 2449, 3, 983, 491, 0, 2449, 2450, 3, 975, 487, 0, 2450, 2451, 3, 1009, 504, 0, 2451, 2452, 3, 979, 489, 0, 2452, 2453, 3, 989, 494, 0, 2453, 312, 1, 0, 0, 0, 2454, 2455, 3, 1011, 505, 0, 2455, 2456, 3, 983, 491, 0, 2456, 2457, 3, 975, 487, 0, 2457, 2458, 3, 1009, 504, 0, 2458, 2459, 3, 979, 489, 0, 2459, 2460, 3, 989, 494, 0, 2460, 2461, 3, 977, 488, 0, 2461, 2462, 3, 975, 487, 0, 2462, 2463, 3, 1009, 504, 0, 2463, 314, 1, 0, 0, 0, 2464, 2465, 3, 1001, 500, 0, 2465, 2466, 3, 975, 487, 0, 2466, 2467, 3, 1017, 508, 0, 2467, 2468, 3, 991, 495, 0, 2468, 2469, 3, 987, 493, 0, 2469, 2470, 3, 975, 487, 0, 2470, 2471, 3, 1013, 506, 0, 2471, 2472, 3, 991, 495, 0, 2472, 2473, 3, 1003, 501, 0, 2473, 2474, 3, 1001, 500, 0, 2474, 2475, 3, 997, 498, 0, 2475, 2476, 3, 991, 495, 0, 2476, 2477, 3, 1011, 505, 0, 2477, 2478, 3, 1013, 506, 0, 2478, 316, 1, 0, 0, 0, 2479, 2480, 3, 975, 487, 0, 2480, 2481, 3, 979, 489, 0, 2481, 2482, 3, 1013, 506, 0, 2482, 2483, 3, 991, 495, 0, 2483, 2484, 3, 1003, 501, 0, 2484, 2485, 3, 1001, 500, 0, 2485, 2486, 3, 977, 488, 0, 2486, 2487, 3, 1015, 507, 0, 2487, 2488, 3, 1013, 506, 0, 2488, 2489, 3, 1013, 506, 0, 2489, 2490, 3, 1003, 501, 0, 2490, 2491, 3, 1001, 500, 0, 2491, 318, 1, 0, 0, 0, 2492, 2493, 3, 997, 498, 0, 2493, 2494, 3, 991, 495, 0, 2494, 2495, 3, 1001, 500, 0, 2495, 2496, 3, 995, 497, 0, 2496, 2497, 3, 977, 488, 0, 2497, 2498, 3, 1015, 507, 0, 2498, 2499, 3, 1013, 506, 0, 2499, 2500, 3, 1013, 506, 0, 2500, 2501, 3, 1003, 501, 0, 2501, 2502, 3, 1001, 500, 0, 2502, 320, 1, 0, 0, 0, 2503, 2504, 3, 977, 488, 0, 2504, 2505, 3, 1015, 507, 0, 2505, 2506, 3, 1013, 506, 0, 2506, 2507, 3, 1013, 506, 0, 2507, 2508, 3, 1003, 501, 0, 2508, 2509, 3, 1001, 500, 0, 2509, 322, 1, 0, 0, 0, 2510, 2511, 3, 1013, 506, 0, 2511, 2512, 3, 991, 495, 0, 2512, 2513, 3, 1013, 506, 0, 2513, 2514, 3, 997, 498, 0, 2514, 2515, 3, 983, 491, 0, 2515, 324, 1, 0, 0, 0, 2516, 2517, 3, 981, 490, 0, 2517, 2518, 3, 1023, 511, 0, 2518, 2519, 3, 1001, 500, 0, 2519, 2520, 3, 975, 487, 0, 2520, 2521, 3, 999, 499, 0, 2521, 2522, 3, 991, 495, 0, 2522, 2523, 3, 979, 489, 0, 2523, 2524, 3, 1013, 506, 0, 2524, 2525, 3, 983, 491, 0, 2525, 2526, 3, 1021, 510, 0, 2526, 2527, 3, 1013, 506, 0, 2527, 326, 1, 0, 0, 0, 2528, 2529, 3, 981, 490, 0, 2529, 2530, 3, 1023, 511, 0, 2530, 2531, 3, 1001, 500, 0, 2531, 2532, 3, 975, 487, 0, 2532, 2533, 3, 999, 499, 0, 2533, 2534, 3, 991, 495, 0, 2534, 2535, 3, 979, 489, 0, 2535, 328, 1, 0, 0, 0, 2536, 2537, 3, 1011, 505, 0, 2537, 2538, 3, 1013, 506, 0, 2538, 2539, 3, 975, 487, 0, 2539, 2540, 3, 1013, 506, 0, 2540, 2541, 3, 991, 495, 0, 2541, 2542, 3, 979, 489, 0, 2542, 2543, 3, 1013, 506, 0, 2543, 2544, 3, 983, 491, 0, 2544, 2545, 3, 1021, 510, 0, 2545, 2546, 3, 1013, 506, 0, 2546, 330, 1, 0, 0, 0, 2547, 2548, 3, 997, 498, 0, 2548, 2549, 3, 975, 487, 0, 2549, 2550, 3, 977, 488, 0, 2550, 2551, 3, 983, 491, 0, 2551, 2552, 3, 997, 498, 0, 2552, 332, 1, 0, 0, 0, 2553, 2554, 3, 1013, 506, 0, 2554, 2555, 3, 983, 491, 0, 2555, 2556, 3, 1021, 510, 0, 2556, 2557, 3, 1013, 506, 0, 2557, 2558, 3, 977, 488, 0, 2558, 2559, 3, 1003, 501, 0, 2559, 2560, 3, 1021, 510, 0, 2560, 334, 1, 0, 0, 0, 2561, 2562, 3, 1013, 506, 0, 2562, 2563, 3, 983, 491, 0, 2563, 2564, 3, 1021, 510, 0, 2564, 2565, 3, 1013, 506, 0, 2565, 2566, 3, 975, 487, 0, 2566, 2567, 3, 1009, 504, 0, 2567, 2568, 3, 983, 491, 0, 2568, 2569, 3, 975, 487, 0, 2569, 336, 1, 0, 0, 0, 2570, 2571, 3, 981, 490, 0, 2571, 2572, 3, 975, 487, 0, 2572, 2573, 3, 1013, 506, 0, 2573, 2574, 3, 983, 491, 0, 2574, 2575, 3, 1005, 502, 0, 2575, 2576, 3, 991, 495, 0, 2576, 2577, 3, 979, 489, 0, 2577, 2578, 3, 995, 497, 0, 2578, 2579, 3, 983, 491, 0, 2579, 2580, 3, 1009, 504, 0, 2580, 338, 1, 0, 0, 0, 2581, 2582, 3, 1009, 504, 0, 2582, 2583, 3, 975, 487, 0, 2583, 2584, 3, 981, 490, 0, 2584, 2585, 3, 991, 495, 0, 2585, 2586, 3, 1003, 501, 0, 2586, 2587, 3, 977, 488, 0, 2587, 2588, 3, 1015, 507, 0, 2588, 2589, 3, 1013, 506, 0, 2589, 2590, 3, 1013, 506, 0, 2590, 2591, 3, 1003, 501, 0, 2591, 2592, 3, 1001, 500, 0, 2592, 2593, 3, 1011, 505, 0, 2593, 340, 1, 0, 0, 0, 2594, 2595, 3, 981, 490, 0, 2595, 2596, 3, 1009, 504, 0, 2596, 2597, 3, 1003, 501, 0, 2597, 2598, 3, 1005, 502, 0, 2598, 2599, 3, 981, 490, 0, 2599, 2600, 3, 1003, 501, 0, 2600, 2601, 3, 1019, 509, 0, 2601, 2602, 3, 1001, 500, 0, 2602, 342, 1, 0, 0, 0, 2603, 2604, 3, 979, 489, 0, 2604, 2605, 3, 1003, 501, 0, 2605, 2606, 3, 999, 499, 0, 2606, 2607, 3, 977, 488, 0, 2607, 2608, 3, 1003, 501, 0, 2608, 2609, 3, 977, 488, 0, 2609, 2610, 3, 1003, 501, 0, 2610, 2611, 3, 1021, 510, 0, 2611, 344, 1, 0, 0, 0, 2612, 2613, 3, 979, 489, 0, 2613, 2614, 3, 989, 494, 0, 2614, 2615, 3, 983, 491, 0, 2615, 2616, 3, 979, 489, 0, 2616, 2617, 3, 995, 497, 0, 2617, 2618, 3, 977, 488, 0, 2618, 2619, 3, 1003, 501, 0, 2619, 2620, 3, 1021, 510, 0, 2620, 346, 1, 0, 0, 0, 2621, 2622, 3, 1009, 504, 0, 2622, 2623, 3, 983, 491, 0, 2623, 2624, 3, 985, 492, 0, 2624, 2625, 3, 983, 491, 0, 2625, 2626, 3, 1009, 504, 0, 2626, 2627, 3, 983, 491, 0, 2627, 2628, 3, 1001, 500, 0, 2628, 2629, 3, 979, 489, 0, 2629, 2630, 3, 983, 491, 0, 2630, 2631, 3, 1011, 505, 0, 2631, 2632, 3, 983, 491, 0, 2632, 2633, 3, 997, 498, 0, 2633, 2634, 3, 983, 491, 0, 2634, 2635, 3, 979, 489, 0, 2635, 2636, 3, 1013, 506, 0, 2636, 2637, 3, 1003, 501, 0, 2637, 2638, 3, 1009, 504, 0, 2638, 348, 1, 0, 0, 0, 2639, 2640, 3, 991, 495, 0, 2640, 2641, 3, 1001, 500, 0, 2641, 2642, 3, 1005, 502, 0, 2642, 2643, 3, 1015, 507, 0, 2643, 2644, 3, 1013, 506, 0, 2644, 2645, 3, 1009, 504, 0, 2645, 2646, 3, 983, 491, 0, 2646, 2647, 3, 985, 492, 0, 2647, 2648, 3, 983, 491, 0, 2648, 2649, 3, 1009, 504, 0, 2649, 2650, 3, 983, 491, 0, 2650, 2651, 3, 1001, 500, 0, 2651, 2652, 3, 979, 489, 0, 2652, 2653, 3, 983, 491, 0, 2653, 2654, 3, 1011, 505, 0, 2654, 2655, 3, 983, 491, 0, 2655, 2656, 3, 1013, 506, 0, 2656, 2657, 3, 1011, 505, 0, 2657, 2658, 3, 983, 491, 0, 2658, 2659, 3, 997, 498, 0, 2659, 2660, 3, 983, 491, 0, 2660, 2661, 3, 979, 489, 0, 2661, 2662, 3, 1013, 506, 0, 2662, 2663, 3, 1003, 501, 0, 2663, 2664, 3, 1009, 504, 0, 2664, 350, 1, 0, 0, 0, 2665, 2666, 3, 985, 492, 0, 2666, 2667, 3, 991, 495, 0, 2667, 2668, 3, 997, 498, 0, 2668, 2669, 3, 983, 491, 0, 2669, 2670, 3, 991, 495, 0, 2670, 2671, 3, 1001, 500, 0, 2671, 2672, 3, 1005, 502, 0, 2672, 2673, 3, 1015, 507, 0, 2673, 2674, 3, 1013, 506, 0, 2674, 352, 1, 0, 0, 0, 2675, 2676, 3, 991, 495, 0, 2676, 2677, 3, 999, 499, 0, 2677, 2678, 3, 975, 487, 0, 2678, 2679, 3, 987, 493, 0, 2679, 2680, 3, 983, 491, 0, 2680, 2681, 3, 991, 495, 0, 2681, 2682, 3, 1001, 500, 0, 2682, 2683, 3, 1005, 502, 0, 2683, 2684, 3, 1015, 507, 0, 2684, 2685, 3, 1013, 506, 0, 2685, 354, 1, 0, 0, 0, 2686, 2687, 3, 979, 489, 0, 2687, 2688, 3, 1015, 507, 0, 2688, 2689, 3, 1011, 505, 0, 2689, 2690, 3, 1013, 506, 0, 2690, 2691, 3, 1003, 501, 0, 2691, 2692, 3, 999, 499, 0, 2692, 2693, 3, 1019, 509, 0, 2693, 2694, 3, 991, 495, 0, 2694, 2695, 3, 981, 490, 0, 2695, 2696, 3, 987, 493, 0, 2696, 2697, 3, 983, 491, 0, 2697, 2698, 3, 1013, 506, 0, 2698, 356, 1, 0, 0, 0, 2699, 2700, 3, 1013, 506, 0, 2700, 2701, 3, 983, 491, 0, 2701, 2702, 3, 1021, 510, 0, 2702, 2703, 3, 1013, 506, 0, 2703, 2704, 3, 985, 492, 0, 2704, 2705, 3, 991, 495, 0, 2705, 2706, 3, 997, 498, 0, 2706, 2707, 3, 1013, 506, 0, 2707, 2708, 3, 983, 491, 0, 2708, 2709, 3, 1009, 504, 0, 2709, 358, 1, 0, 0, 0, 2710, 2711, 3, 1001, 500, 0, 2711, 2712, 3, 1015, 507, 0, 2712, 2713, 3, 999, 499, 0, 2713, 2714, 3, 977, 488, 0, 2714, 2715, 3, 983, 491, 0, 2715, 2716, 3, 1009, 504, 0, 2716, 2717, 3, 985, 492, 0, 2717, 2718, 3, 991, 495, 0, 2718, 2719, 3, 997, 498, 0, 2719, 2720, 3, 1013, 506, 0, 2720, 2721, 3, 983, 491, 0, 2721, 2722, 3, 1009, 504, 0, 2722, 360, 1, 0, 0, 0, 2723, 2724, 3, 981, 490, 0, 2724, 2725, 3, 1009, 504, 0, 2725, 2726, 3, 1003, 501, 0, 2726, 2727, 3, 1005, 502, 0, 2727, 2728, 3, 981, 490, 0, 2728, 2729, 3, 1003, 501, 0, 2729, 2730, 3, 1019, 509, 0, 2730, 2731, 3, 1001, 500, 0, 2731, 2732, 3, 985, 492, 0, 2732, 2733, 3, 991, 495, 0, 2733, 2734, 3, 997, 498, 0, 2734, 2735, 3, 1013, 506, 0, 2735, 2736, 3, 983, 491, 0, 2736, 2737, 3, 1009, 504, 0, 2737, 362, 1, 0, 0, 0, 2738, 2739, 3, 981, 490, 0, 2739, 2740, 3, 975, 487, 0, 2740, 2741, 3, 1013, 506, 0, 2741, 2742, 3, 983, 491, 0, 2742, 2743, 3, 985, 492, 0, 2743, 2744, 3, 991, 495, 0, 2744, 2745, 3, 997, 498, 0, 2745, 2746, 3, 1013, 506, 0, 2746, 2747, 3, 983, 491, 0, 2747, 2748, 3, 1009, 504, 0, 2748, 364, 1, 0, 0, 0, 2749, 2750, 3, 985, 492, 0, 2750, 2751, 3, 991, 495, 0, 2751, 2752, 3, 997, 498, 0, 2752, 2753, 3, 1013, 506, 0, 2753, 2754, 3, 983, 491, 0, 2754, 2755, 3, 1009, 504, 0, 2755, 366, 1, 0, 0, 0, 2756, 2757, 3, 1019, 509, 0, 2757, 2758, 3, 991, 495, 0, 2758, 2759, 3, 981, 490, 0, 2759, 2760, 3, 987, 493, 0, 2760, 2761, 3, 983, 491, 0, 2761, 2762, 3, 1013, 506, 0, 2762, 368, 1, 0, 0, 0, 2763, 2764, 3, 1019, 509, 0, 2764, 2765, 3, 991, 495, 0, 2765, 2766, 3, 981, 490, 0, 2766, 2767, 3, 987, 493, 0, 2767, 2768, 3, 983, 491, 0, 2768, 2769, 3, 1013, 506, 0, 2769, 2770, 3, 1011, 505, 0, 2770, 370, 1, 0, 0, 0, 2771, 2772, 3, 979, 489, 0, 2772, 2773, 3, 975, 487, 0, 2773, 2774, 3, 1005, 502, 0, 2774, 2775, 3, 1013, 506, 0, 2775, 2776, 3, 991, 495, 0, 2776, 2777, 3, 1003, 501, 0, 2777, 2778, 3, 1001, 500, 0, 2778, 372, 1, 0, 0, 0, 2779, 2780, 3, 991, 495, 0, 2780, 2781, 3, 979, 489, 0, 2781, 2782, 3, 1003, 501, 0, 2782, 2783, 3, 1001, 500, 0, 2783, 374, 1, 0, 0, 0, 2784, 2785, 3, 1013, 506, 0, 2785, 2786, 3, 1003, 501, 0, 2786, 2787, 3, 1003, 501, 0, 2787, 2788, 3, 997, 498, 0, 2788, 2789, 3, 1013, 506, 0, 2789, 2790, 3, 991, 495, 0, 2790, 2791, 3, 1005, 502, 0, 2791, 376, 1, 0, 0, 0, 2792, 2793, 3, 981, 490, 0, 2793, 2794, 3, 975, 487, 0, 2794, 2795, 3, 1013, 506, 0, 2795, 2796, 3, 975, 487, 0, 2796, 2797, 3, 1011, 505, 0, 2797, 2798, 3, 1003, 501, 0, 2798, 2799, 3, 1015, 507, 0, 2799, 2800, 3, 1009, 504, 0, 2800, 2801, 3, 979, 489, 0, 2801, 2802, 3, 983, 491, 0, 2802, 378, 1, 0, 0, 0, 2803, 2804, 3, 1011, 505, 0, 2804, 2805, 3, 1003, 501, 0, 2805, 2806, 3, 1015, 507, 0, 2806, 2807, 3, 1009, 504, 0, 2807, 2808, 3, 979, 489, 0, 2808, 2809, 3, 983, 491, 0, 2809, 380, 1, 0, 0, 0, 2810, 2811, 3, 1011, 505, 0, 2811, 2812, 3, 983, 491, 0, 2812, 2813, 3, 997, 498, 0, 2813, 2814, 3, 983, 491, 0, 2814, 2815, 3, 979, 489, 0, 2815, 2816, 3, 1013, 506, 0, 2816, 2817, 3, 991, 495, 0, 2817, 2818, 3, 1003, 501, 0, 2818, 2819, 3, 1001, 500, 0, 2819, 382, 1, 0, 0, 0, 2820, 2821, 3, 985, 492, 0, 2821, 2822, 3, 1003, 501, 0, 2822, 2823, 3, 1003, 501, 0, 2823, 2824, 3, 1013, 506, 0, 2824, 2825, 3, 983, 491, 0, 2825, 2826, 3, 1009, 504, 0, 2826, 384, 1, 0, 0, 0, 2827, 2828, 3, 989, 494, 0, 2828, 2829, 3, 983, 491, 0, 2829, 2830, 3, 975, 487, 0, 2830, 2831, 3, 981, 490, 0, 2831, 2832, 3, 983, 491, 0, 2832, 2833, 3, 1009, 504, 0, 2833, 386, 1, 0, 0, 0, 2834, 2835, 3, 979, 489, 0, 2835, 2836, 3, 1003, 501, 0, 2836, 2837, 3, 1001, 500, 0, 2837, 2838, 3, 1013, 506, 0, 2838, 2839, 3, 983, 491, 0, 2839, 2840, 3, 1001, 500, 0, 2840, 2841, 3, 1013, 506, 0, 2841, 388, 1, 0, 0, 0, 2842, 2843, 3, 1009, 504, 0, 2843, 2844, 3, 983, 491, 0, 2844, 2845, 3, 1001, 500, 0, 2845, 2846, 3, 981, 490, 0, 2846, 2847, 3, 983, 491, 0, 2847, 2848, 3, 1009, 504, 0, 2848, 2849, 3, 999, 499, 0, 2849, 2850, 3, 1003, 501, 0, 2850, 2851, 3, 981, 490, 0, 2851, 2852, 3, 983, 491, 0, 2852, 390, 1, 0, 0, 0, 2853, 2854, 3, 977, 488, 0, 2854, 2855, 3, 991, 495, 0, 2855, 2856, 3, 1001, 500, 0, 2856, 2857, 3, 981, 490, 0, 2857, 2858, 3, 1011, 505, 0, 2858, 392, 1, 0, 0, 0, 2859, 2860, 3, 975, 487, 0, 2860, 2861, 3, 1013, 506, 0, 2861, 2862, 3, 1013, 506, 0, 2862, 2863, 3, 1009, 504, 0, 2863, 394, 1, 0, 0, 0, 2864, 2865, 3, 979, 489, 0, 2865, 2866, 3, 1003, 501, 0, 2866, 2867, 3, 1001, 500, 0, 2867, 2868, 3, 1013, 506, 0, 2868, 2869, 3, 983, 491, 0, 2869, 2870, 3, 1001, 500, 0, 2870, 2871, 3, 1013, 506, 0, 2871, 2872, 3, 1005, 502, 0, 2872, 2873, 3, 975, 487, 0, 2873, 2874, 3, 1009, 504, 0, 2874, 2875, 3, 975, 487, 0, 2875, 2876, 3, 999, 499, 0, 2876, 2877, 3, 1011, 505, 0, 2877, 396, 1, 0, 0, 0, 2878, 2879, 3, 979, 489, 0, 2879, 2880, 3, 975, 487, 0, 2880, 2881, 3, 1005, 502, 0, 2881, 2882, 3, 1013, 506, 0, 2882, 2883, 3, 991, 495, 0, 2883, 2884, 3, 1003, 501, 0, 2884, 2885, 3, 1001, 500, 0, 2885, 2886, 3, 1005, 502, 0, 2886, 2887, 3, 975, 487, 0, 2887, 2888, 3, 1009, 504, 0, 2888, 2889, 3, 975, 487, 0, 2889, 2890, 3, 999, 499, 0, 2890, 2891, 3, 1011, 505, 0, 2891, 398, 1, 0, 0, 0, 2892, 2893, 3, 1005, 502, 0, 2893, 2894, 3, 975, 487, 0, 2894, 2895, 3, 1009, 504, 0, 2895, 2896, 3, 975, 487, 0, 2896, 2897, 3, 999, 499, 0, 2897, 2898, 3, 1011, 505, 0, 2898, 400, 1, 0, 0, 0, 2899, 2900, 3, 1017, 508, 0, 2900, 2901, 3, 975, 487, 0, 2901, 2902, 3, 1009, 504, 0, 2902, 2903, 3, 991, 495, 0, 2903, 2904, 3, 975, 487, 0, 2904, 2905, 3, 977, 488, 0, 2905, 2906, 3, 997, 498, 0, 2906, 2907, 3, 983, 491, 0, 2907, 2908, 3, 1011, 505, 0, 2908, 402, 1, 0, 0, 0, 2909, 2910, 3, 981, 490, 0, 2910, 2911, 3, 983, 491, 0, 2911, 2912, 3, 1011, 505, 0, 2912, 2913, 3, 995, 497, 0, 2913, 2914, 3, 1013, 506, 0, 2914, 2915, 3, 1003, 501, 0, 2915, 2916, 3, 1005, 502, 0, 2916, 2917, 3, 1019, 509, 0, 2917, 2918, 3, 991, 495, 0, 2918, 2919, 3, 981, 490, 0, 2919, 2920, 3, 1013, 506, 0, 2920, 2921, 3, 989, 494, 0, 2921, 404, 1, 0, 0, 0, 2922, 2923, 3, 979, 489, 0, 2923, 2924, 3, 997, 498, 0, 2924, 2925, 3, 975, 487, 0, 2925, 2926, 3, 1011, 505, 0, 2926, 2927, 3, 1011, 505, 0, 2927, 406, 1, 0, 0, 0, 2928, 2929, 3, 1011, 505, 0, 2929, 2930, 3, 1013, 506, 0, 2930, 2931, 3, 1023, 511, 0, 2931, 2932, 3, 997, 498, 0, 2932, 2933, 3, 983, 491, 0, 2933, 408, 1, 0, 0, 0, 2934, 2935, 3, 977, 488, 0, 2935, 2936, 3, 1015, 507, 0, 2936, 2937, 3, 1013, 506, 0, 2937, 2938, 3, 1013, 506, 0, 2938, 2939, 3, 1003, 501, 0, 2939, 2940, 3, 1001, 500, 0, 2940, 2941, 3, 1011, 505, 0, 2941, 2942, 3, 1013, 506, 0, 2942, 2943, 3, 1023, 511, 0, 2943, 2944, 3, 997, 498, 0, 2944, 2945, 3, 983, 491, 0, 2945, 410, 1, 0, 0, 0, 2946, 2947, 3, 981, 490, 0, 2947, 2948, 3, 983, 491, 0, 2948, 2949, 3, 1011, 505, 0, 2949, 2950, 3, 991, 495, 0, 2950, 2951, 3, 987, 493, 0, 2951, 2952, 3, 1001, 500, 0, 2952, 412, 1, 0, 0, 0, 2953, 2954, 3, 1005, 502, 0, 2954, 2955, 3, 1009, 504, 0, 2955, 2956, 3, 1003, 501, 0, 2956, 2957, 3, 1005, 502, 0, 2957, 2958, 3, 983, 491, 0, 2958, 2959, 3, 1009, 504, 0, 2959, 2960, 3, 1013, 506, 0, 2960, 2961, 3, 991, 495, 0, 2961, 2962, 3, 983, 491, 0, 2962, 2963, 3, 1011, 505, 0, 2963, 414, 1, 0, 0, 0, 2964, 2965, 3, 981, 490, 0, 2965, 2966, 3, 983, 491, 0, 2966, 2967, 3, 1011, 505, 0, 2967, 2968, 3, 991, 495, 0, 2968, 2969, 3, 987, 493, 0, 2969, 2970, 3, 1001, 500, 0, 2970, 2971, 3, 1005, 502, 0, 2971, 2972, 3, 1009, 504, 0, 2972, 2973, 3, 1003, 501, 0, 2973, 2974, 3, 1005, 502, 0, 2974, 2975, 3, 983, 491, 0, 2975, 2976, 3, 1009, 504, 0, 2976, 2977, 3, 1013, 506, 0, 2977, 2978, 3, 991, 495, 0, 2978, 2979, 3, 983, 491, 0, 2979, 2980, 3, 1011, 505, 0, 2980, 416, 1, 0, 0, 0, 2981, 2982, 3, 1011, 505, 0, 2982, 2983, 3, 1013, 506, 0, 2983, 2984, 3, 1023, 511, 0, 2984, 2985, 3, 997, 498, 0, 2985, 2986, 3, 991, 495, 0, 2986, 2987, 3, 1001, 500, 0, 2987, 2988, 3, 987, 493, 0, 2988, 418, 1, 0, 0, 0, 2989, 2990, 3, 979, 489, 0, 2990, 2991, 3, 997, 498, 0, 2991, 2992, 3, 983, 491, 0, 2992, 2993, 3, 975, 487, 0, 2993, 2994, 3, 1009, 504, 0, 2994, 420, 1, 0, 0, 0, 2995, 2996, 3, 1019, 509, 0, 2996, 2997, 3, 991, 495, 0, 2997, 2998, 3, 981, 490, 0, 2998, 2999, 3, 1013, 506, 0, 2999, 3000, 3, 989, 494, 0, 3000, 422, 1, 0, 0, 0, 3001, 3002, 3, 989, 494, 0, 3002, 3003, 3, 983, 491, 0, 3003, 3004, 3, 991, 495, 0, 3004, 3005, 3, 987, 493, 0, 3005, 3006, 3, 989, 494, 0, 3006, 3007, 3, 1013, 506, 0, 3007, 424, 1, 0, 0, 0, 3008, 3009, 3, 975, 487, 0, 3009, 3010, 3, 1015, 507, 0, 3010, 3011, 3, 1013, 506, 0, 3011, 3012, 3, 1003, 501, 0, 3012, 3013, 3, 985, 492, 0, 3013, 3014, 3, 991, 495, 0, 3014, 3015, 3, 997, 498, 0, 3015, 3016, 3, 997, 498, 0, 3016, 426, 1, 0, 0, 0, 3017, 3018, 3, 1015, 507, 0, 3018, 3019, 3, 1009, 504, 0, 3019, 3020, 3, 997, 498, 0, 3020, 428, 1, 0, 0, 0, 3021, 3022, 3, 985, 492, 0, 3022, 3023, 3, 1003, 501, 0, 3023, 3024, 3, 997, 498, 0, 3024, 3025, 3, 981, 490, 0, 3025, 3026, 3, 983, 491, 0, 3026, 3027, 3, 1009, 504, 0, 3027, 430, 1, 0, 0, 0, 3028, 3029, 3, 1005, 502, 0, 3029, 3030, 3, 975, 487, 0, 3030, 3031, 3, 1011, 505, 0, 3031, 3032, 3, 1011, 505, 0, 3032, 3033, 3, 991, 495, 0, 3033, 3034, 3, 1001, 500, 0, 3034, 3035, 3, 987, 493, 0, 3035, 432, 1, 0, 0, 0, 3036, 3037, 3, 979, 489, 0, 3037, 3038, 3, 1003, 501, 0, 3038, 3039, 3, 1001, 500, 0, 3039, 3040, 3, 1013, 506, 0, 3040, 3041, 3, 983, 491, 0, 3041, 3042, 3, 1021, 510, 0, 3042, 3043, 3, 1013, 506, 0, 3043, 434, 1, 0, 0, 0, 3044, 3045, 3, 983, 491, 0, 3045, 3046, 3, 981, 490, 0, 3046, 3047, 3, 991, 495, 0, 3047, 3048, 3, 1013, 506, 0, 3048, 3049, 3, 975, 487, 0, 3049, 3050, 3, 977, 488, 0, 3050, 3051, 3, 997, 498, 0, 3051, 3052, 3, 983, 491, 0, 3052, 436, 1, 0, 0, 0, 3053, 3054, 3, 1009, 504, 0, 3054, 3055, 3, 983, 491, 0, 3055, 3056, 3, 975, 487, 0, 3056, 3057, 3, 981, 490, 0, 3057, 3058, 3, 1003, 501, 0, 3058, 3059, 3, 1001, 500, 0, 3059, 3060, 3, 997, 498, 0, 3060, 3061, 3, 1023, 511, 0, 3061, 438, 1, 0, 0, 0, 3062, 3063, 3, 975, 487, 0, 3063, 3064, 3, 1013, 506, 0, 3064, 3065, 3, 1013, 506, 0, 3065, 3066, 3, 1009, 504, 0, 3066, 3067, 3, 991, 495, 0, 3067, 3068, 3, 977, 488, 0, 3068, 3069, 3, 1015, 507, 0, 3069, 3070, 3, 1013, 506, 0, 3070, 3071, 3, 983, 491, 0, 3071, 3072, 3, 1011, 505, 0, 3072, 440, 1, 0, 0, 0, 3073, 3074, 3, 985, 492, 0, 3074, 3075, 3, 991, 495, 0, 3075, 3076, 3, 997, 498, 0, 3076, 3077, 3, 1013, 506, 0, 3077, 3078, 3, 983, 491, 0, 3078, 3079, 3, 1009, 504, 0, 3079, 3080, 3, 1013, 506, 0, 3080, 3081, 3, 1023, 511, 0, 3081, 3082, 3, 1005, 502, 0, 3082, 3083, 3, 983, 491, 0, 3083, 442, 1, 0, 0, 0, 3084, 3085, 3, 991, 495, 0, 3085, 3086, 3, 999, 499, 0, 3086, 3087, 3, 975, 487, 0, 3087, 3088, 3, 987, 493, 0, 3088, 3089, 3, 983, 491, 0, 3089, 444, 1, 0, 0, 0, 3090, 3091, 3, 1011, 505, 0, 3091, 3092, 3, 1013, 506, 0, 3092, 3093, 3, 975, 487, 0, 3093, 3094, 3, 1013, 506, 0, 3094, 3095, 3, 991, 495, 0, 3095, 3096, 3, 979, 489, 0, 3096, 3097, 3, 991, 495, 0, 3097, 3098, 3, 999, 499, 0, 3098, 3099, 3, 975, 487, 0, 3099, 3100, 3, 987, 493, 0, 3100, 3101, 3, 983, 491, 0, 3101, 446, 1, 0, 0, 0, 3102, 3103, 3, 981, 490, 0, 3103, 3104, 3, 1023, 511, 0, 3104, 3105, 3, 1001, 500, 0, 3105, 3106, 3, 975, 487, 0, 3106, 3107, 3, 999, 499, 0, 3107, 3108, 3, 991, 495, 0, 3108, 3109, 3, 979, 489, 0, 3109, 3110, 3, 991, 495, 0, 3110, 3111, 3, 999, 499, 0, 3111, 3112, 3, 975, 487, 0, 3112, 3113, 3, 987, 493, 0, 3113, 3114, 3, 983, 491, 0, 3114, 448, 1, 0, 0, 0, 3115, 3116, 3, 979, 489, 0, 3116, 3117, 3, 1015, 507, 0, 3117, 3118, 3, 1011, 505, 0, 3118, 3119, 3, 1013, 506, 0, 3119, 3120, 3, 1003, 501, 0, 3120, 3121, 3, 999, 499, 0, 3121, 3122, 3, 979, 489, 0, 3122, 3123, 3, 1003, 501, 0, 3123, 3124, 3, 1001, 500, 0, 3124, 3125, 3, 1013, 506, 0, 3125, 3126, 3, 975, 487, 0, 3126, 3127, 3, 991, 495, 0, 3127, 3128, 3, 1001, 500, 0, 3128, 3129, 3, 983, 491, 0, 3129, 3130, 3, 1009, 504, 0, 3130, 450, 1, 0, 0, 0, 3131, 3132, 3, 987, 493, 0, 3132, 3133, 3, 1009, 504, 0, 3133, 3134, 3, 1003, 501, 0, 3134, 3135, 3, 1015, 507, 0, 3135, 3136, 3, 1005, 502, 0, 3136, 3137, 3, 977, 488, 0, 3137, 3138, 3, 1003, 501, 0, 3138, 3139, 3, 1021, 510, 0, 3139, 452, 1, 0, 0, 0, 3140, 3141, 3, 1017, 508, 0, 3141, 3142, 3, 991, 495, 0, 3142, 3143, 3, 1011, 505, 0, 3143, 3144, 3, 991, 495, 0, 3144, 3145, 3, 977, 488, 0, 3145, 3146, 3, 997, 498, 0, 3146, 3147, 3, 983, 491, 0, 3147, 454, 1, 0, 0, 0, 3148, 3149, 3, 1011, 505, 0, 3149, 3150, 3, 975, 487, 0, 3150, 3151, 3, 1017, 508, 0, 3151, 3152, 3, 983, 491, 0, 3152, 3153, 3, 979, 489, 0, 3153, 3154, 3, 989, 494, 0, 3154, 3155, 3, 975, 487, 0, 3155, 3156, 3, 1001, 500, 0, 3156, 3157, 3, 987, 493, 0, 3157, 3158, 3, 983, 491, 0, 3158, 3159, 3, 1011, 505, 0, 3159, 456, 1, 0, 0, 0, 3160, 3161, 3, 1011, 505, 0, 3161, 3162, 3, 975, 487, 0, 3162, 3163, 3, 1017, 508, 0, 3163, 3164, 3, 983, 491, 0, 3164, 3165, 5, 95, 0, 0, 3165, 3166, 3, 979, 489, 0, 3166, 3167, 3, 989, 494, 0, 3167, 3168, 3, 975, 487, 0, 3168, 3169, 3, 1001, 500, 0, 3169, 3170, 3, 987, 493, 0, 3170, 3171, 3, 983, 491, 0, 3171, 3172, 3, 1011, 505, 0, 3172, 458, 1, 0, 0, 0, 3173, 3174, 3, 979, 489, 0, 3174, 3175, 3, 975, 487, 0, 3175, 3176, 3, 1001, 500, 0, 3176, 3177, 3, 979, 489, 0, 3177, 3178, 3, 983, 491, 0, 3178, 3179, 3, 997, 498, 0, 3179, 3180, 5, 95, 0, 0, 3180, 3181, 3, 979, 489, 0, 3181, 3182, 3, 989, 494, 0, 3182, 3183, 3, 975, 487, 0, 3183, 3184, 3, 1001, 500, 0, 3184, 3185, 3, 987, 493, 0, 3185, 3186, 3, 983, 491, 0, 3186, 3187, 3, 1011, 505, 0, 3187, 460, 1, 0, 0, 0, 3188, 3189, 3, 979, 489, 0, 3189, 3190, 3, 997, 498, 0, 3190, 3191, 3, 1003, 501, 0, 3191, 3192, 3, 1011, 505, 0, 3192, 3193, 3, 983, 491, 0, 3193, 3194, 5, 95, 0, 0, 3194, 3195, 3, 1005, 502, 0, 3195, 3196, 3, 975, 487, 0, 3196, 3197, 3, 987, 493, 0, 3197, 3198, 3, 983, 491, 0, 3198, 462, 1, 0, 0, 0, 3199, 3200, 3, 1011, 505, 0, 3200, 3201, 3, 989, 494, 0, 3201, 3202, 3, 1003, 501, 0, 3202, 3203, 3, 1019, 509, 0, 3203, 3204, 5, 95, 0, 0, 3204, 3205, 3, 1005, 502, 0, 3205, 3206, 3, 975, 487, 0, 3206, 3207, 3, 987, 493, 0, 3207, 3208, 3, 983, 491, 0, 3208, 464, 1, 0, 0, 0, 3209, 3210, 3, 981, 490, 0, 3210, 3211, 3, 983, 491, 0, 3211, 3212, 3, 997, 498, 0, 3212, 3213, 3, 983, 491, 0, 3213, 3214, 3, 1013, 506, 0, 3214, 3215, 3, 983, 491, 0, 3215, 3216, 5, 95, 0, 0, 3216, 3217, 3, 975, 487, 0, 3217, 3218, 3, 979, 489, 0, 3218, 3219, 3, 1013, 506, 0, 3219, 3220, 3, 991, 495, 0, 3220, 3221, 3, 1003, 501, 0, 3221, 3222, 3, 1001, 500, 0, 3222, 466, 1, 0, 0, 0, 3223, 3224, 3, 981, 490, 0, 3224, 3225, 3, 983, 491, 0, 3225, 3226, 3, 997, 498, 0, 3226, 3227, 3, 983, 491, 0, 3227, 3228, 3, 1013, 506, 0, 3228, 3229, 3, 983, 491, 0, 3229, 3230, 5, 95, 0, 0, 3230, 3231, 3, 1003, 501, 0, 3231, 3232, 3, 977, 488, 0, 3232, 3233, 3, 993, 496, 0, 3233, 3234, 3, 983, 491, 0, 3234, 3235, 3, 979, 489, 0, 3235, 3236, 3, 1013, 506, 0, 3236, 468, 1, 0, 0, 0, 3237, 3238, 3, 979, 489, 0, 3238, 3239, 3, 1009, 504, 0, 3239, 3240, 3, 983, 491, 0, 3240, 3241, 3, 975, 487, 0, 3241, 3242, 3, 1013, 506, 0, 3242, 3243, 3, 983, 491, 0, 3243, 3244, 5, 95, 0, 0, 3244, 3245, 3, 1003, 501, 0, 3245, 3246, 3, 977, 488, 0, 3246, 3247, 3, 993, 496, 0, 3247, 3248, 3, 983, 491, 0, 3248, 3249, 3, 979, 489, 0, 3249, 3250, 3, 1013, 506, 0, 3250, 470, 1, 0, 0, 0, 3251, 3252, 3, 979, 489, 0, 3252, 3253, 3, 975, 487, 0, 3253, 3254, 3, 997, 498, 0, 3254, 3255, 3, 997, 498, 0, 3255, 3256, 5, 95, 0, 0, 3256, 3257, 3, 999, 499, 0, 3257, 3258, 3, 991, 495, 0, 3258, 3259, 3, 979, 489, 0, 3259, 3260, 3, 1009, 504, 0, 3260, 3261, 3, 1003, 501, 0, 3261, 3262, 3, 985, 492, 0, 3262, 3263, 3, 997, 498, 0, 3263, 3264, 3, 1003, 501, 0, 3264, 3265, 3, 1019, 509, 0, 3265, 472, 1, 0, 0, 0, 3266, 3267, 3, 979, 489, 0, 3267, 3268, 3, 975, 487, 0, 3268, 3269, 3, 997, 498, 0, 3269, 3270, 3, 997, 498, 0, 3270, 3271, 5, 95, 0, 0, 3271, 3272, 3, 1001, 500, 0, 3272, 3273, 3, 975, 487, 0, 3273, 3274, 3, 1001, 500, 0, 3274, 3275, 3, 1003, 501, 0, 3275, 3276, 3, 985, 492, 0, 3276, 3277, 3, 997, 498, 0, 3277, 3278, 3, 1003, 501, 0, 3278, 3279, 3, 1019, 509, 0, 3279, 474, 1, 0, 0, 0, 3280, 3281, 3, 1003, 501, 0, 3281, 3282, 3, 1005, 502, 0, 3282, 3283, 3, 983, 491, 0, 3283, 3284, 3, 1001, 500, 0, 3284, 3285, 5, 95, 0, 0, 3285, 3286, 3, 997, 498, 0, 3286, 3287, 3, 991, 495, 0, 3287, 3288, 3, 1001, 500, 0, 3288, 3289, 3, 995, 497, 0, 3289, 476, 1, 0, 0, 0, 3290, 3291, 3, 1011, 505, 0, 3291, 3292, 3, 991, 495, 0, 3292, 3293, 3, 987, 493, 0, 3293, 3294, 3, 1001, 500, 0, 3294, 3295, 5, 95, 0, 0, 3295, 3296, 3, 1003, 501, 0, 3296, 3297, 3, 1015, 507, 0, 3297, 3298, 3, 1013, 506, 0, 3298, 478, 1, 0, 0, 0, 3299, 3300, 3, 979, 489, 0, 3300, 3301, 3, 975, 487, 0, 3301, 3302, 3, 1001, 500, 0, 3302, 3303, 3, 979, 489, 0, 3303, 3304, 3, 983, 491, 0, 3304, 3305, 3, 997, 498, 0, 3305, 480, 1, 0, 0, 0, 3306, 3307, 3, 1005, 502, 0, 3307, 3308, 3, 1009, 504, 0, 3308, 3309, 3, 991, 495, 0, 3309, 3310, 3, 999, 499, 0, 3310, 3311, 3, 975, 487, 0, 3311, 3312, 3, 1009, 504, 0, 3312, 3313, 3, 1023, 511, 0, 3313, 482, 1, 0, 0, 0, 3314, 3315, 3, 1011, 505, 0, 3315, 3316, 3, 1015, 507, 0, 3316, 3317, 3, 979, 489, 0, 3317, 3318, 3, 979, 489, 0, 3318, 3319, 3, 983, 491, 0, 3319, 3320, 3, 1011, 505, 0, 3320, 3321, 3, 1011, 505, 0, 3321, 484, 1, 0, 0, 0, 3322, 3323, 3, 981, 490, 0, 3323, 3324, 3, 975, 487, 0, 3324, 3325, 3, 1001, 500, 0, 3325, 3326, 3, 987, 493, 0, 3326, 3327, 3, 983, 491, 0, 3327, 3328, 3, 1009, 504, 0, 3328, 486, 1, 0, 0, 0, 3329, 3330, 3, 1019, 509, 0, 3330, 3331, 3, 975, 487, 0, 3331, 3332, 3, 1009, 504, 0, 3332, 3333, 3, 1001, 500, 0, 3333, 3334, 3, 991, 495, 0, 3334, 3335, 3, 1001, 500, 0, 3335, 3336, 3, 987, 493, 0, 3336, 488, 1, 0, 0, 0, 3337, 3338, 3, 991, 495, 0, 3338, 3339, 3, 1001, 500, 0, 3339, 3340, 3, 985, 492, 0, 3340, 3341, 3, 1003, 501, 0, 3341, 490, 1, 0, 0, 0, 3342, 3343, 3, 1013, 506, 0, 3343, 3344, 3, 983, 491, 0, 3344, 3345, 3, 999, 499, 0, 3345, 3346, 3, 1005, 502, 0, 3346, 3347, 3, 997, 498, 0, 3347, 3348, 3, 975, 487, 0, 3348, 3349, 3, 1013, 506, 0, 3349, 3350, 3, 983, 491, 0, 3350, 492, 1, 0, 0, 0, 3351, 3352, 3, 1003, 501, 0, 3352, 3353, 3, 1001, 500, 0, 3353, 3354, 3, 979, 489, 0, 3354, 3355, 3, 997, 498, 0, 3355, 3356, 3, 991, 495, 0, 3356, 3357, 3, 979, 489, 0, 3357, 3358, 3, 995, 497, 0, 3358, 494, 1, 0, 0, 0, 3359, 3360, 3, 1003, 501, 0, 3360, 3361, 3, 1001, 500, 0, 3361, 3362, 3, 979, 489, 0, 3362, 3363, 3, 989, 494, 0, 3363, 3364, 3, 975, 487, 0, 3364, 3365, 3, 1001, 500, 0, 3365, 3366, 3, 987, 493, 0, 3366, 3367, 3, 983, 491, 0, 3367, 496, 1, 0, 0, 0, 3368, 3369, 3, 1013, 506, 0, 3369, 3370, 3, 975, 487, 0, 3370, 3371, 3, 977, 488, 0, 3371, 3372, 3, 991, 495, 0, 3372, 3373, 3, 1001, 500, 0, 3373, 3374, 3, 981, 490, 0, 3374, 3375, 3, 983, 491, 0, 3375, 3376, 3, 1021, 510, 0, 3376, 498, 1, 0, 0, 0, 3377, 3378, 3, 989, 494, 0, 3378, 3379, 5, 49, 0, 0, 3379, 500, 1, 0, 0, 0, 3380, 3381, 3, 989, 494, 0, 3381, 3382, 5, 50, 0, 0, 3382, 502, 1, 0, 0, 0, 3383, 3384, 3, 989, 494, 0, 3384, 3385, 5, 51, 0, 0, 3385, 504, 1, 0, 0, 0, 3386, 3387, 3, 989, 494, 0, 3387, 3388, 5, 52, 0, 0, 3388, 506, 1, 0, 0, 0, 3389, 3390, 3, 989, 494, 0, 3390, 3391, 5, 53, 0, 0, 3391, 508, 1, 0, 0, 0, 3392, 3393, 3, 989, 494, 0, 3393, 3394, 5, 54, 0, 0, 3394, 510, 1, 0, 0, 0, 3395, 3396, 3, 1005, 502, 0, 3396, 3397, 3, 975, 487, 0, 3397, 3398, 3, 1009, 504, 0, 3398, 3399, 3, 975, 487, 0, 3399, 3400, 3, 987, 493, 0, 3400, 3401, 3, 1009, 504, 0, 3401, 3402, 3, 975, 487, 0, 3402, 3403, 3, 1005, 502, 0, 3403, 3404, 3, 989, 494, 0, 3404, 512, 1, 0, 0, 0, 3405, 3406, 3, 1011, 505, 0, 3406, 3407, 3, 1013, 506, 0, 3407, 3408, 3, 1009, 504, 0, 3408, 3409, 3, 991, 495, 0, 3409, 3410, 3, 1001, 500, 0, 3410, 3411, 3, 987, 493, 0, 3411, 514, 1, 0, 0, 0, 3412, 3413, 3, 991, 495, 0, 3413, 3414, 3, 1001, 500, 0, 3414, 3415, 3, 1013, 506, 0, 3415, 3416, 3, 983, 491, 0, 3416, 3417, 3, 987, 493, 0, 3417, 3418, 3, 983, 491, 0, 3418, 3419, 3, 1009, 504, 0, 3419, 516, 1, 0, 0, 0, 3420, 3421, 3, 997, 498, 0, 3421, 3422, 3, 1003, 501, 0, 3422, 3423, 3, 1001, 500, 0, 3423, 3424, 3, 987, 493, 0, 3424, 518, 1, 0, 0, 0, 3425, 3426, 3, 981, 490, 0, 3426, 3427, 3, 983, 491, 0, 3427, 3428, 3, 979, 489, 0, 3428, 3429, 3, 991, 495, 0, 3429, 3430, 3, 999, 499, 0, 3430, 3431, 3, 975, 487, 0, 3431, 3432, 3, 997, 498, 0, 3432, 520, 1, 0, 0, 0, 3433, 3434, 3, 977, 488, 0, 3434, 3435, 3, 1003, 501, 0, 3435, 3436, 3, 1003, 501, 0, 3436, 3437, 3, 997, 498, 0, 3437, 3438, 3, 983, 491, 0, 3438, 3439, 3, 975, 487, 0, 3439, 3440, 3, 1001, 500, 0, 3440, 522, 1, 0, 0, 0, 3441, 3442, 3, 981, 490, 0, 3442, 3443, 3, 975, 487, 0, 3443, 3444, 3, 1013, 506, 0, 3444, 3445, 3, 983, 491, 0, 3445, 3446, 3, 1013, 506, 0, 3446, 3447, 3, 991, 495, 0, 3447, 3448, 3, 999, 499, 0, 3448, 3449, 3, 983, 491, 0, 3449, 524, 1, 0, 0, 0, 3450, 3451, 3, 981, 490, 0, 3451, 3452, 3, 975, 487, 0, 3452, 3453, 3, 1013, 506, 0, 3453, 3454, 3, 983, 491, 0, 3454, 526, 1, 0, 0, 0, 3455, 3456, 3, 975, 487, 0, 3456, 3457, 3, 1015, 507, 0, 3457, 3458, 3, 1013, 506, 0, 3458, 3459, 3, 1003, 501, 0, 3459, 3460, 3, 1001, 500, 0, 3460, 3461, 3, 1015, 507, 0, 3461, 3462, 3, 999, 499, 0, 3462, 3463, 3, 977, 488, 0, 3463, 3464, 3, 983, 491, 0, 3464, 3465, 3, 1009, 504, 0, 3465, 528, 1, 0, 0, 0, 3466, 3467, 3, 977, 488, 0, 3467, 3468, 3, 991, 495, 0, 3468, 3469, 3, 1001, 500, 0, 3469, 3470, 3, 975, 487, 0, 3470, 3471, 3, 1009, 504, 0, 3471, 3472, 3, 1023, 511, 0, 3472, 530, 1, 0, 0, 0, 3473, 3474, 3, 989, 494, 0, 3474, 3475, 3, 975, 487, 0, 3475, 3476, 3, 1011, 505, 0, 3476, 3477, 3, 989, 494, 0, 3477, 3478, 3, 983, 491, 0, 3478, 3479, 3, 981, 490, 0, 3479, 3480, 3, 1011, 505, 0, 3480, 3481, 3, 1013, 506, 0, 3481, 3482, 3, 1009, 504, 0, 3482, 3483, 3, 991, 495, 0, 3483, 3484, 3, 1001, 500, 0, 3484, 3485, 3, 987, 493, 0, 3485, 532, 1, 0, 0, 0, 3486, 3487, 3, 979, 489, 0, 3487, 3488, 3, 1015, 507, 0, 3488, 3489, 3, 1009, 504, 0, 3489, 3490, 3, 1009, 504, 0, 3490, 3491, 3, 983, 491, 0, 3491, 3492, 3, 1001, 500, 0, 3492, 3493, 3, 979, 489, 0, 3493, 3494, 3, 1023, 511, 0, 3494, 534, 1, 0, 0, 0, 3495, 3496, 3, 985, 492, 0, 3496, 3497, 3, 997, 498, 0, 3497, 3498, 3, 1003, 501, 0, 3498, 3499, 3, 975, 487, 0, 3499, 3500, 3, 1013, 506, 0, 3500, 536, 1, 0, 0, 0, 3501, 3502, 3, 1011, 505, 0, 3502, 3503, 3, 1013, 506, 0, 3503, 3504, 3, 1009, 504, 0, 3504, 3505, 3, 991, 495, 0, 3505, 3506, 3, 1001, 500, 0, 3506, 3507, 3, 987, 493, 0, 3507, 3508, 3, 1013, 506, 0, 3508, 3509, 3, 983, 491, 0, 3509, 3510, 3, 999, 499, 0, 3510, 3511, 3, 1005, 502, 0, 3511, 3512, 3, 997, 498, 0, 3512, 3513, 3, 975, 487, 0, 3513, 3514, 3, 1013, 506, 0, 3514, 3515, 3, 983, 491, 0, 3515, 538, 1, 0, 0, 0, 3516, 3517, 3, 983, 491, 0, 3517, 3518, 3, 1001, 500, 0, 3518, 3519, 3, 1015, 507, 0, 3519, 3520, 3, 999, 499, 0, 3520, 540, 1, 0, 0, 0, 3521, 3522, 3, 979, 489, 0, 3522, 3523, 3, 1003, 501, 0, 3523, 3524, 3, 1015, 507, 0, 3524, 3525, 3, 1001, 500, 0, 3525, 3526, 3, 1013, 506, 0, 3526, 542, 1, 0, 0, 0, 3527, 3528, 3, 1011, 505, 0, 3528, 3529, 3, 1015, 507, 0, 3529, 3530, 3, 999, 499, 0, 3530, 544, 1, 0, 0, 0, 3531, 3532, 3, 975, 487, 0, 3532, 3533, 3, 1017, 508, 0, 3533, 3534, 3, 987, 493, 0, 3534, 546, 1, 0, 0, 0, 3535, 3536, 3, 999, 499, 0, 3536, 3537, 3, 991, 495, 0, 3537, 3538, 3, 1001, 500, 0, 3538, 548, 1, 0, 0, 0, 3539, 3540, 3, 999, 499, 0, 3540, 3541, 3, 975, 487, 0, 3541, 3542, 3, 1021, 510, 0, 3542, 550, 1, 0, 0, 0, 3543, 3544, 3, 997, 498, 0, 3544, 3545, 3, 983, 491, 0, 3545, 3546, 3, 1001, 500, 0, 3546, 3547, 3, 987, 493, 0, 3547, 3548, 3, 1013, 506, 0, 3548, 3549, 3, 989, 494, 0, 3549, 552, 1, 0, 0, 0, 3550, 3551, 3, 1013, 506, 0, 3551, 3552, 3, 1009, 504, 0, 3552, 3553, 3, 991, 495, 0, 3553, 3554, 3, 999, 499, 0, 3554, 554, 1, 0, 0, 0, 3555, 3556, 3, 979, 489, 0, 3556, 3557, 3, 1003, 501, 0, 3557, 3558, 3, 975, 487, 0, 3558, 3559, 3, 997, 498, 0, 3559, 3560, 3, 983, 491, 0, 3560, 3561, 3, 1011, 505, 0, 3561, 3562, 3, 979, 489, 0, 3562, 3563, 3, 983, 491, 0, 3563, 556, 1, 0, 0, 0, 3564, 3565, 3, 979, 489, 0, 3565, 3566, 3, 975, 487, 0, 3566, 3567, 3, 1011, 505, 0, 3567, 3568, 3, 1013, 506, 0, 3568, 558, 1, 0, 0, 0, 3569, 3570, 3, 975, 487, 0, 3570, 3571, 3, 1001, 500, 0, 3571, 3572, 3, 981, 490, 0, 3572, 560, 1, 0, 0, 0, 3573, 3574, 3, 1003, 501, 0, 3574, 3575, 3, 1009, 504, 0, 3575, 562, 1, 0, 0, 0, 3576, 3577, 3, 1001, 500, 0, 3577, 3578, 3, 1003, 501, 0, 3578, 3579, 3, 1013, 506, 0, 3579, 564, 1, 0, 0, 0, 3580, 3581, 3, 1001, 500, 0, 3581, 3582, 3, 1015, 507, 0, 3582, 3583, 3, 997, 498, 0, 3583, 3584, 3, 997, 498, 0, 3584, 566, 1, 0, 0, 0, 3585, 3586, 3, 991, 495, 0, 3586, 3587, 3, 1001, 500, 0, 3587, 568, 1, 0, 0, 0, 3588, 3589, 3, 977, 488, 0, 3589, 3590, 3, 983, 491, 0, 3590, 3591, 3, 1013, 506, 0, 3591, 3592, 3, 1019, 509, 0, 3592, 3593, 3, 983, 491, 0, 3593, 3594, 3, 983, 491, 0, 3594, 3595, 3, 1001, 500, 0, 3595, 570, 1, 0, 0, 0, 3596, 3597, 3, 997, 498, 0, 3597, 3598, 3, 991, 495, 0, 3598, 3599, 3, 995, 497, 0, 3599, 3600, 3, 983, 491, 0, 3600, 572, 1, 0, 0, 0, 3601, 3602, 3, 999, 499, 0, 3602, 3603, 3, 975, 487, 0, 3603, 3604, 3, 1013, 506, 0, 3604, 3605, 3, 979, 489, 0, 3605, 3606, 3, 989, 494, 0, 3606, 574, 1, 0, 0, 0, 3607, 3608, 3, 983, 491, 0, 3608, 3609, 3, 1021, 510, 0, 3609, 3610, 3, 991, 495, 0, 3610, 3611, 3, 1011, 505, 0, 3611, 3612, 3, 1013, 506, 0, 3612, 3613, 3, 1011, 505, 0, 3613, 576, 1, 0, 0, 0, 3614, 3615, 3, 1015, 507, 0, 3615, 3616, 3, 1001, 500, 0, 3616, 3617, 3, 991, 495, 0, 3617, 3618, 3, 1007, 503, 0, 3618, 3619, 3, 1015, 507, 0, 3619, 3620, 3, 983, 491, 0, 3620, 578, 1, 0, 0, 0, 3621, 3622, 3, 981, 490, 0, 3622, 3623, 3, 983, 491, 0, 3623, 3624, 3, 985, 492, 0, 3624, 3625, 3, 975, 487, 0, 3625, 3626, 3, 1015, 507, 0, 3626, 3627, 3, 997, 498, 0, 3627, 3628, 3, 1013, 506, 0, 3628, 580, 1, 0, 0, 0, 3629, 3630, 3, 1013, 506, 0, 3630, 3631, 3, 1009, 504, 0, 3631, 3632, 3, 1015, 507, 0, 3632, 3633, 3, 983, 491, 0, 3633, 582, 1, 0, 0, 0, 3634, 3635, 3, 985, 492, 0, 3635, 3636, 3, 975, 487, 0, 3636, 3637, 3, 997, 498, 0, 3637, 3638, 3, 1011, 505, 0, 3638, 3639, 3, 983, 491, 0, 3639, 584, 1, 0, 0, 0, 3640, 3641, 3, 1017, 508, 0, 3641, 3642, 3, 975, 487, 0, 3642, 3643, 3, 997, 498, 0, 3643, 3644, 3, 991, 495, 0, 3644, 3645, 3, 981, 490, 0, 3645, 3646, 3, 975, 487, 0, 3646, 3647, 3, 1013, 506, 0, 3647, 3648, 3, 991, 495, 0, 3648, 3649, 3, 1003, 501, 0, 3649, 3650, 3, 1001, 500, 0, 3650, 586, 1, 0, 0, 0, 3651, 3652, 3, 985, 492, 0, 3652, 3653, 3, 983, 491, 0, 3653, 3654, 3, 983, 491, 0, 3654, 3655, 3, 981, 490, 0, 3655, 3656, 3, 977, 488, 0, 3656, 3657, 3, 975, 487, 0, 3657, 3658, 3, 979, 489, 0, 3658, 3659, 3, 995, 497, 0, 3659, 588, 1, 0, 0, 0, 3660, 3661, 3, 1009, 504, 0, 3661, 3662, 3, 1015, 507, 0, 3662, 3663, 3, 997, 498, 0, 3663, 3664, 3, 983, 491, 0, 3664, 590, 1, 0, 0, 0, 3665, 3666, 3, 1009, 504, 0, 3666, 3667, 3, 983, 491, 0, 3667, 3668, 3, 1007, 503, 0, 3668, 3669, 3, 1015, 507, 0, 3669, 3670, 3, 991, 495, 0, 3670, 3671, 3, 1009, 504, 0, 3671, 3672, 3, 983, 491, 0, 3672, 3673, 3, 981, 490, 0, 3673, 592, 1, 0, 0, 0, 3674, 3675, 3, 983, 491, 0, 3675, 3676, 3, 1009, 504, 0, 3676, 3677, 3, 1009, 504, 0, 3677, 3678, 3, 1003, 501, 0, 3678, 3679, 3, 1009, 504, 0, 3679, 594, 1, 0, 0, 0, 3680, 3681, 3, 1009, 504, 0, 3681, 3682, 3, 975, 487, 0, 3682, 3683, 3, 991, 495, 0, 3683, 3684, 3, 1011, 505, 0, 3684, 3685, 3, 983, 491, 0, 3685, 596, 1, 0, 0, 0, 3686, 3687, 3, 1009, 504, 0, 3687, 3688, 3, 975, 487, 0, 3688, 3689, 3, 1001, 500, 0, 3689, 3690, 3, 987, 493, 0, 3690, 3691, 3, 983, 491, 0, 3691, 598, 1, 0, 0, 0, 3692, 3693, 3, 1009, 504, 0, 3693, 3694, 3, 983, 491, 0, 3694, 3695, 3, 987, 493, 0, 3695, 3696, 3, 983, 491, 0, 3696, 3697, 3, 1021, 510, 0, 3697, 600, 1, 0, 0, 0, 3698, 3699, 3, 1005, 502, 0, 3699, 3700, 3, 975, 487, 0, 3700, 3701, 3, 1013, 506, 0, 3701, 3702, 3, 1013, 506, 0, 3702, 3703, 3, 983, 491, 0, 3703, 3704, 3, 1009, 504, 0, 3704, 3705, 3, 1001, 500, 0, 3705, 602, 1, 0, 0, 0, 3706, 3707, 3, 983, 491, 0, 3707, 3708, 3, 1021, 510, 0, 3708, 3709, 3, 1005, 502, 0, 3709, 3710, 3, 1009, 504, 0, 3710, 3711, 3, 983, 491, 0, 3711, 3712, 3, 1011, 505, 0, 3712, 3713, 3, 1011, 505, 0, 3713, 3714, 3, 991, 495, 0, 3714, 3715, 3, 1003, 501, 0, 3715, 3716, 3, 1001, 500, 0, 3716, 604, 1, 0, 0, 0, 3717, 3718, 3, 1021, 510, 0, 3718, 3719, 3, 1005, 502, 0, 3719, 3720, 3, 975, 487, 0, 3720, 3721, 3, 1013, 506, 0, 3721, 3722, 3, 989, 494, 0, 3722, 606, 1, 0, 0, 0, 3723, 3724, 3, 979, 489, 0, 3724, 3725, 3, 1003, 501, 0, 3725, 3726, 3, 1001, 500, 0, 3726, 3727, 3, 1011, 505, 0, 3727, 3728, 3, 1013, 506, 0, 3728, 3729, 3, 1009, 504, 0, 3729, 3730, 3, 975, 487, 0, 3730, 3731, 3, 991, 495, 0, 3731, 3732, 3, 1001, 500, 0, 3732, 3733, 3, 1013, 506, 0, 3733, 608, 1, 0, 0, 0, 3734, 3735, 3, 1009, 504, 0, 3735, 3736, 3, 983, 491, 0, 3736, 3737, 3, 1011, 505, 0, 3737, 3738, 3, 1013, 506, 0, 3738, 610, 1, 0, 0, 0, 3739, 3740, 3, 1011, 505, 0, 3740, 3741, 3, 983, 491, 0, 3741, 3742, 3, 1009, 504, 0, 3742, 3743, 3, 1017, 508, 0, 3743, 3744, 3, 991, 495, 0, 3744, 3745, 3, 979, 489, 0, 3745, 3746, 3, 983, 491, 0, 3746, 612, 1, 0, 0, 0, 3747, 3748, 3, 1011, 505, 0, 3748, 3749, 3, 983, 491, 0, 3749, 3750, 3, 1009, 504, 0, 3750, 3751, 3, 1017, 508, 0, 3751, 3752, 3, 991, 495, 0, 3752, 3753, 3, 979, 489, 0, 3753, 3754, 3, 983, 491, 0, 3754, 3755, 3, 1011, 505, 0, 3755, 614, 1, 0, 0, 0, 3756, 3757, 3, 1003, 501, 0, 3757, 3758, 3, 981, 490, 0, 3758, 3759, 3, 975, 487, 0, 3759, 3760, 3, 1013, 506, 0, 3760, 3761, 3, 975, 487, 0, 3761, 616, 1, 0, 0, 0, 3762, 3763, 3, 977, 488, 0, 3763, 3764, 3, 975, 487, 0, 3764, 3765, 3, 1011, 505, 0, 3765, 3766, 3, 983, 491, 0, 3766, 618, 1, 0, 0, 0, 3767, 3768, 3, 975, 487, 0, 3768, 3769, 3, 1015, 507, 0, 3769, 3770, 3, 1013, 506, 0, 3770, 3771, 3, 989, 494, 0, 3771, 620, 1, 0, 0, 0, 3772, 3773, 3, 975, 487, 0, 3773, 3774, 3, 1015, 507, 0, 3774, 3775, 3, 1013, 506, 0, 3775, 3776, 3, 989, 494, 0, 3776, 3777, 3, 983, 491, 0, 3777, 3778, 3, 1001, 500, 0, 3778, 3779, 3, 1013, 506, 0, 3779, 3780, 3, 991, 495, 0, 3780, 3781, 3, 979, 489, 0, 3781, 3782, 3, 975, 487, 0, 3782, 3783, 3, 1013, 506, 0, 3783, 3784, 3, 991, 495, 0, 3784, 3785, 3, 1003, 501, 0, 3785, 3786, 3, 1001, 500, 0, 3786, 622, 1, 0, 0, 0, 3787, 3788, 3, 977, 488, 0, 3788, 3789, 3, 975, 487, 0, 3789, 3790, 3, 1011, 505, 0, 3790, 3791, 3, 991, 495, 0, 3791, 3792, 3, 979, 489, 0, 3792, 624, 1, 0, 0, 0, 3793, 3794, 3, 1001, 500, 0, 3794, 3795, 3, 1003, 501, 0, 3795, 3796, 3, 1013, 506, 0, 3796, 3797, 3, 989, 494, 0, 3797, 3798, 3, 991, 495, 0, 3798, 3799, 3, 1001, 500, 0, 3799, 3800, 3, 987, 493, 0, 3800, 626, 1, 0, 0, 0, 3801, 3802, 3, 1003, 501, 0, 3802, 3803, 3, 975, 487, 0, 3803, 3804, 3, 1015, 507, 0, 3804, 3805, 3, 1013, 506, 0, 3805, 3806, 3, 989, 494, 0, 3806, 628, 1, 0, 0, 0, 3807, 3808, 3, 1003, 501, 0, 3808, 3809, 3, 1005, 502, 0, 3809, 3810, 3, 983, 491, 0, 3810, 3811, 3, 1009, 504, 0, 3811, 3812, 3, 975, 487, 0, 3812, 3813, 3, 1013, 506, 0, 3813, 3814, 3, 991, 495, 0, 3814, 3815, 3, 1003, 501, 0, 3815, 3816, 3, 1001, 500, 0, 3816, 630, 1, 0, 0, 0, 3817, 3818, 3, 999, 499, 0, 3818, 3819, 3, 983, 491, 0, 3819, 3820, 3, 1013, 506, 0, 3820, 3821, 3, 989, 494, 0, 3821, 3822, 3, 1003, 501, 0, 3822, 3823, 3, 981, 490, 0, 3823, 632, 1, 0, 0, 0, 3824, 3825, 3, 1005, 502, 0, 3825, 3826, 3, 975, 487, 0, 3826, 3827, 3, 1013, 506, 0, 3827, 3828, 3, 989, 494, 0, 3828, 634, 1, 0, 0, 0, 3829, 3830, 3, 1013, 506, 0, 3830, 3831, 3, 991, 495, 0, 3831, 3832, 3, 999, 499, 0, 3832, 3833, 3, 983, 491, 0, 3833, 3834, 3, 1003, 501, 0, 3834, 3835, 3, 1015, 507, 0, 3835, 3836, 3, 1013, 506, 0, 3836, 636, 1, 0, 0, 0, 3837, 3838, 3, 977, 488, 0, 3838, 3839, 3, 1003, 501, 0, 3839, 3840, 3, 981, 490, 0, 3840, 3841, 3, 1023, 511, 0, 3841, 638, 1, 0, 0, 0, 3842, 3843, 3, 1009, 504, 0, 3843, 3844, 3, 983, 491, 0, 3844, 3845, 3, 1011, 505, 0, 3845, 3846, 3, 1005, 502, 0, 3846, 3847, 3, 1003, 501, 0, 3847, 3848, 3, 1001, 500, 0, 3848, 3849, 3, 1011, 505, 0, 3849, 3850, 3, 983, 491, 0, 3850, 640, 1, 0, 0, 0, 3851, 3852, 3, 1009, 504, 0, 3852, 3853, 3, 983, 491, 0, 3853, 3854, 3, 1007, 503, 0, 3854, 3855, 3, 1015, 507, 0, 3855, 3856, 3, 983, 491, 0, 3856, 3857, 3, 1011, 505, 0, 3857, 3858, 3, 1013, 506, 0, 3858, 642, 1, 0, 0, 0, 3859, 3860, 3, 993, 496, 0, 3860, 3861, 3, 1011, 505, 0, 3861, 3862, 3, 1003, 501, 0, 3862, 3863, 3, 1001, 500, 0, 3863, 644, 1, 0, 0, 0, 3864, 3865, 3, 1021, 510, 0, 3865, 3866, 3, 999, 499, 0, 3866, 3867, 3, 997, 498, 0, 3867, 646, 1, 0, 0, 0, 3868, 3869, 3, 1011, 505, 0, 3869, 3870, 3, 1013, 506, 0, 3870, 3871, 3, 975, 487, 0, 3871, 3872, 3, 1013, 506, 0, 3872, 3873, 3, 1015, 507, 0, 3873, 3874, 3, 1011, 505, 0, 3874, 648, 1, 0, 0, 0, 3875, 3876, 3, 1017, 508, 0, 3876, 3877, 3, 983, 491, 0, 3877, 3878, 3, 1009, 504, 0, 3878, 3879, 3, 1011, 505, 0, 3879, 3880, 3, 991, 495, 0, 3880, 3881, 3, 1003, 501, 0, 3881, 3882, 3, 1001, 500, 0, 3882, 650, 1, 0, 0, 0, 3883, 3884, 3, 987, 493, 0, 3884, 3885, 3, 983, 491, 0, 3885, 3886, 3, 1013, 506, 0, 3886, 652, 1, 0, 0, 0, 3887, 3888, 3, 1005, 502, 0, 3888, 3889, 3, 1003, 501, 0, 3889, 3890, 3, 1011, 505, 0, 3890, 3891, 3, 1013, 506, 0, 3891, 654, 1, 0, 0, 0, 3892, 3893, 3, 1005, 502, 0, 3893, 3894, 3, 1015, 507, 0, 3894, 3895, 3, 1013, 506, 0, 3895, 656, 1, 0, 0, 0, 3896, 3897, 3, 1005, 502, 0, 3897, 3898, 3, 975, 487, 0, 3898, 3899, 3, 1013, 506, 0, 3899, 3900, 3, 979, 489, 0, 3900, 3901, 3, 989, 494, 0, 3901, 658, 1, 0, 0, 0, 3902, 3903, 3, 975, 487, 0, 3903, 3904, 3, 1005, 502, 0, 3904, 3905, 3, 991, 495, 0, 3905, 660, 1, 0, 0, 0, 3906, 3907, 3, 979, 489, 0, 3907, 3908, 3, 997, 498, 0, 3908, 3909, 3, 991, 495, 0, 3909, 3910, 3, 983, 491, 0, 3910, 3911, 3, 1001, 500, 0, 3911, 3912, 3, 1013, 506, 0, 3912, 662, 1, 0, 0, 0, 3913, 3914, 3, 979, 489, 0, 3914, 3915, 3, 997, 498, 0, 3915, 3916, 3, 991, 495, 0, 3916, 3917, 3, 983, 491, 0, 3917, 3918, 3, 1001, 500, 0, 3918, 3919, 3, 1013, 506, 0, 3919, 3920, 3, 1011, 505, 0, 3920, 664, 1, 0, 0, 0, 3921, 3922, 3, 1005, 502, 0, 3922, 3923, 3, 1015, 507, 0, 3923, 3924, 3, 977, 488, 0, 3924, 3925, 3, 997, 498, 0, 3925, 3926, 3, 991, 495, 0, 3926, 3927, 3, 1011, 505, 0, 3927, 3928, 3, 989, 494, 0, 3928, 666, 1, 0, 0, 0, 3929, 3930, 3, 983, 491, 0, 3930, 3931, 3, 1021, 510, 0, 3931, 3932, 3, 1005, 502, 0, 3932, 3933, 3, 1003, 501, 0, 3933, 3934, 3, 1011, 505, 0, 3934, 3935, 3, 983, 491, 0, 3935, 668, 1, 0, 0, 0, 3936, 3937, 3, 1001, 500, 0, 3937, 3938, 3, 975, 487, 0, 3938, 3939, 3, 999, 499, 0, 3939, 3940, 3, 983, 491, 0, 3940, 3941, 3, 1011, 505, 0, 3941, 3942, 3, 1005, 502, 0, 3942, 3943, 3, 975, 487, 0, 3943, 3944, 3, 979, 489, 0, 3944, 3945, 3, 983, 491, 0, 3945, 670, 1, 0, 0, 0, 3946, 3947, 3, 1011, 505, 0, 3947, 3948, 3, 983, 491, 0, 3948, 3949, 3, 1011, 505, 0, 3949, 3950, 3, 1011, 505, 0, 3950, 3951, 3, 991, 495, 0, 3951, 3952, 3, 1003, 501, 0, 3952, 3953, 3, 1001, 500, 0, 3953, 672, 1, 0, 0, 0, 3954, 3955, 3, 987, 493, 0, 3955, 3956, 3, 1015, 507, 0, 3956, 3957, 3, 983, 491, 0, 3957, 3958, 3, 1011, 505, 0, 3958, 3959, 3, 1013, 506, 0, 3959, 674, 1, 0, 0, 0, 3960, 3961, 3, 1005, 502, 0, 3961, 3962, 3, 975, 487, 0, 3962, 3963, 3, 987, 493, 0, 3963, 3964, 3, 991, 495, 0, 3964, 3965, 3, 1001, 500, 0, 3965, 3966, 3, 987, 493, 0, 3966, 676, 1, 0, 0, 0, 3967, 3968, 3, 1001, 500, 0, 3968, 3969, 3, 1003, 501, 0, 3969, 3970, 3, 1013, 506, 0, 3970, 3971, 5, 95, 0, 0, 3971, 3972, 3, 1011, 505, 0, 3972, 3973, 3, 1015, 507, 0, 3973, 3974, 3, 1005, 502, 0, 3974, 3975, 3, 1005, 502, 0, 3975, 3976, 3, 1003, 501, 0, 3976, 3977, 3, 1009, 504, 0, 3977, 3978, 3, 1013, 506, 0, 3978, 3979, 3, 983, 491, 0, 3979, 3980, 3, 981, 490, 0, 3980, 678, 1, 0, 0, 0, 3981, 3982, 3, 1015, 507, 0, 3982, 3983, 3, 1011, 505, 0, 3983, 3984, 3, 983, 491, 0, 3984, 3985, 3, 1009, 504, 0, 3985, 3986, 3, 1001, 500, 0, 3986, 3987, 3, 975, 487, 0, 3987, 3988, 3, 999, 499, 0, 3988, 3989, 3, 983, 491, 0, 3989, 680, 1, 0, 0, 0, 3990, 3991, 3, 1005, 502, 0, 3991, 3992, 3, 975, 487, 0, 3992, 3993, 3, 1011, 505, 0, 3993, 3994, 3, 1011, 505, 0, 3994, 3995, 3, 1019, 509, 0, 3995, 3996, 3, 1003, 501, 0, 3996, 3997, 3, 1009, 504, 0, 3997, 3998, 3, 981, 490, 0, 3998, 682, 1, 0, 0, 0, 3999, 4000, 3, 979, 489, 0, 4000, 4001, 3, 1003, 501, 0, 4001, 4002, 3, 1001, 500, 0, 4002, 4003, 3, 1001, 500, 0, 4003, 4004, 3, 983, 491, 0, 4004, 4005, 3, 979, 489, 0, 4005, 4006, 3, 1013, 506, 0, 4006, 4007, 3, 991, 495, 0, 4007, 4008, 3, 1003, 501, 0, 4008, 4009, 3, 1001, 500, 0, 4009, 684, 1, 0, 0, 0, 4010, 4011, 3, 981, 490, 0, 4011, 4012, 3, 975, 487, 0, 4012, 4013, 3, 1013, 506, 0, 4013, 4014, 3, 975, 487, 0, 4014, 4015, 3, 977, 488, 0, 4015, 4016, 3, 975, 487, 0, 4016, 4017, 3, 1011, 505, 0, 4017, 4018, 3, 983, 491, 0, 4018, 686, 1, 0, 0, 0, 4019, 4020, 3, 1007, 503, 0, 4020, 4021, 3, 1015, 507, 0, 4021, 4022, 3, 983, 491, 0, 4022, 4023, 3, 1009, 504, 0, 4023, 4024, 3, 1023, 511, 0, 4024, 688, 1, 0, 0, 0, 4025, 4026, 3, 999, 499, 0, 4026, 4027, 3, 975, 487, 0, 4027, 4028, 3, 1005, 502, 0, 4028, 690, 1, 0, 0, 0, 4029, 4030, 3, 999, 499, 0, 4030, 4031, 3, 975, 487, 0, 4031, 4032, 3, 1005, 502, 0, 4032, 4033, 3, 1005, 502, 0, 4033, 4034, 3, 991, 495, 0, 4034, 4035, 3, 1001, 500, 0, 4035, 4036, 3, 987, 493, 0, 4036, 692, 1, 0, 0, 0, 4037, 4038, 3, 991, 495, 0, 4038, 4039, 3, 999, 499, 0, 4039, 4040, 3, 1005, 502, 0, 4040, 4041, 3, 1003, 501, 0, 4041, 4042, 3, 1009, 504, 0, 4042, 4043, 3, 1013, 506, 0, 4043, 694, 1, 0, 0, 0, 4044, 4045, 3, 991, 495, 0, 4045, 4046, 3, 1001, 500, 0, 4046, 4047, 3, 1013, 506, 0, 4047, 4048, 3, 1003, 501, 0, 4048, 696, 1, 0, 0, 0, 4049, 4050, 3, 977, 488, 0, 4050, 4051, 3, 975, 487, 0, 4051, 4052, 3, 1013, 506, 0, 4052, 4053, 3, 979, 489, 0, 4053, 4054, 3, 989, 494, 0, 4054, 698, 1, 0, 0, 0, 4055, 4056, 3, 997, 498, 0, 4056, 4057, 3, 991, 495, 0, 4057, 4058, 3, 1001, 500, 0, 4058, 4059, 3, 995, 497, 0, 4059, 700, 1, 0, 0, 0, 4060, 4061, 3, 983, 491, 0, 4061, 4062, 3, 1021, 510, 0, 4062, 4063, 3, 1005, 502, 0, 4063, 4064, 3, 1003, 501, 0, 4064, 4065, 3, 1009, 504, 0, 4065, 4066, 3, 1013, 506, 0, 4066, 702, 1, 0, 0, 0, 4067, 4068, 3, 987, 493, 0, 4068, 4069, 3, 983, 491, 0, 4069, 4070, 3, 1001, 500, 0, 4070, 4071, 3, 983, 491, 0, 4071, 4072, 3, 1009, 504, 0, 4072, 4073, 3, 975, 487, 0, 4073, 4074, 3, 1013, 506, 0, 4074, 4075, 3, 983, 491, 0, 4075, 704, 1, 0, 0, 0, 4076, 4077, 3, 979, 489, 0, 4077, 4078, 3, 1003, 501, 0, 4078, 4079, 3, 1001, 500, 0, 4079, 4080, 3, 1001, 500, 0, 4080, 4081, 3, 983, 491, 0, 4081, 4082, 3, 979, 489, 0, 4082, 4083, 3, 1013, 506, 0, 4083, 4084, 3, 1003, 501, 0, 4084, 4085, 3, 1009, 504, 0, 4085, 706, 1, 0, 0, 0, 4086, 4087, 3, 983, 491, 0, 4087, 4088, 3, 1021, 510, 0, 4088, 4089, 3, 983, 491, 0, 4089, 4090, 3, 979, 489, 0, 4090, 708, 1, 0, 0, 0, 4091, 4092, 3, 1013, 506, 0, 4092, 4093, 3, 975, 487, 0, 4093, 4094, 3, 977, 488, 0, 4094, 4095, 3, 997, 498, 0, 4095, 4096, 3, 983, 491, 0, 4096, 4097, 3, 1011, 505, 0, 4097, 710, 1, 0, 0, 0, 4098, 4099, 3, 1017, 508, 0, 4099, 4100, 3, 991, 495, 0, 4100, 4101, 3, 983, 491, 0, 4101, 4102, 3, 1019, 509, 0, 4102, 4103, 3, 1011, 505, 0, 4103, 712, 1, 0, 0, 0, 4104, 4105, 3, 983, 491, 0, 4105, 4106, 3, 1021, 510, 0, 4106, 4107, 3, 1005, 502, 0, 4107, 4108, 3, 1003, 501, 0, 4108, 4109, 3, 1011, 505, 0, 4109, 4110, 3, 983, 491, 0, 4110, 4111, 3, 981, 490, 0, 4111, 714, 1, 0, 0, 0, 4112, 4113, 3, 1005, 502, 0, 4113, 4114, 3, 975, 487, 0, 4114, 4115, 3, 1009, 504, 0, 4115, 4116, 3, 975, 487, 0, 4116, 4117, 3, 999, 499, 0, 4117, 4118, 3, 983, 491, 0, 4118, 4119, 3, 1013, 506, 0, 4119, 4120, 3, 983, 491, 0, 4120, 4121, 3, 1009, 504, 0, 4121, 716, 1, 0, 0, 0, 4122, 4123, 3, 1005, 502, 0, 4123, 4124, 3, 975, 487, 0, 4124, 4125, 3, 1009, 504, 0, 4125, 4126, 3, 975, 487, 0, 4126, 4127, 3, 999, 499, 0, 4127, 4128, 3, 983, 491, 0, 4128, 4129, 3, 1013, 506, 0, 4129, 4130, 3, 983, 491, 0, 4130, 4131, 3, 1009, 504, 0, 4131, 4132, 3, 1011, 505, 0, 4132, 718, 1, 0, 0, 0, 4133, 4134, 3, 989, 494, 0, 4134, 4135, 3, 983, 491, 0, 4135, 4136, 3, 975, 487, 0, 4136, 4137, 3, 981, 490, 0, 4137, 4138, 3, 983, 491, 0, 4138, 4139, 3, 1009, 504, 0, 4139, 4140, 3, 1011, 505, 0, 4140, 720, 1, 0, 0, 0, 4141, 4142, 3, 1001, 500, 0, 4142, 4143, 3, 975, 487, 0, 4143, 4144, 3, 1017, 508, 0, 4144, 4145, 3, 991, 495, 0, 4145, 4146, 3, 987, 493, 0, 4146, 4147, 3, 975, 487, 0, 4147, 4148, 3, 1013, 506, 0, 4148, 4149, 3, 991, 495, 0, 4149, 4150, 3, 1003, 501, 0, 4150, 4151, 3, 1001, 500, 0, 4151, 722, 1, 0, 0, 0, 4152, 4153, 3, 999, 499, 0, 4153, 4154, 3, 983, 491, 0, 4154, 4155, 3, 1001, 500, 0, 4155, 4156, 3, 1015, 507, 0, 4156, 724, 1, 0, 0, 0, 4157, 4158, 3, 989, 494, 0, 4158, 4159, 3, 1003, 501, 0, 4159, 4160, 3, 999, 499, 0, 4160, 4161, 3, 983, 491, 0, 4161, 4162, 3, 1011, 505, 0, 4162, 726, 1, 0, 0, 0, 4163, 4164, 3, 989, 494, 0, 4164, 4165, 3, 1003, 501, 0, 4165, 4166, 3, 999, 499, 0, 4166, 4167, 3, 983, 491, 0, 4167, 728, 1, 0, 0, 0, 4168, 4169, 3, 997, 498, 0, 4169, 4170, 3, 1003, 501, 0, 4170, 4171, 3, 987, 493, 0, 4171, 4172, 3, 991, 495, 0, 4172, 4173, 3, 1001, 500, 0, 4173, 730, 1, 0, 0, 0, 4174, 4175, 3, 985, 492, 0, 4175, 4176, 3, 1003, 501, 0, 4176, 4177, 3, 1015, 507, 0, 4177, 4178, 3, 1001, 500, 0, 4178, 4179, 3, 981, 490, 0, 4179, 732, 1, 0, 0, 0, 4180, 4181, 3, 999, 499, 0, 4181, 4182, 3, 1003, 501, 0, 4182, 4183, 3, 981, 490, 0, 4183, 4184, 3, 1015, 507, 0, 4184, 4185, 3, 997, 498, 0, 4185, 4186, 3, 983, 491, 0, 4186, 4187, 3, 1011, 505, 0, 4187, 734, 1, 0, 0, 0, 4188, 4189, 3, 983, 491, 0, 4189, 4190, 3, 1001, 500, 0, 4190, 4191, 3, 1013, 506, 0, 4191, 4192, 3, 991, 495, 0, 4192, 4193, 3, 1013, 506, 0, 4193, 4194, 3, 991, 495, 0, 4194, 4195, 3, 983, 491, 0, 4195, 4196, 3, 1011, 505, 0, 4196, 736, 1, 0, 0, 0, 4197, 4198, 3, 975, 487, 0, 4198, 4199, 3, 1011, 505, 0, 4199, 4200, 3, 1011, 505, 0, 4200, 4201, 3, 1003, 501, 0, 4201, 4202, 3, 979, 489, 0, 4202, 4203, 3, 991, 495, 0, 4203, 4204, 3, 975, 487, 0, 4204, 4205, 3, 1013, 506, 0, 4205, 4206, 3, 991, 495, 0, 4206, 4207, 3, 1003, 501, 0, 4207, 4208, 3, 1001, 500, 0, 4208, 4209, 3, 1011, 505, 0, 4209, 738, 1, 0, 0, 0, 4210, 4211, 3, 999, 499, 0, 4211, 4212, 3, 991, 495, 0, 4212, 4213, 3, 979, 489, 0, 4213, 4214, 3, 1009, 504, 0, 4214, 4215, 3, 1003, 501, 0, 4215, 4216, 3, 985, 492, 0, 4216, 4217, 3, 997, 498, 0, 4217, 4218, 3, 1003, 501, 0, 4218, 4219, 3, 1019, 509, 0, 4219, 4220, 3, 1011, 505, 0, 4220, 740, 1, 0, 0, 0, 4221, 4222, 3, 1001, 500, 0, 4222, 4223, 3, 975, 487, 0, 4223, 4224, 3, 1001, 500, 0, 4224, 4225, 3, 1003, 501, 0, 4225, 4226, 3, 985, 492, 0, 4226, 4227, 3, 997, 498, 0, 4227, 4228, 3, 1003, 501, 0, 4228, 4229, 3, 1019, 509, 0, 4229, 4230, 3, 1011, 505, 0, 4230, 742, 1, 0, 0, 0, 4231, 4232, 3, 1019, 509, 0, 4232, 4233, 3, 1003, 501, 0, 4233, 4234, 3, 1009, 504, 0, 4234, 4235, 3, 995, 497, 0, 4235, 4236, 3, 985, 492, 0, 4236, 4237, 3, 997, 498, 0, 4237, 4238, 3, 1003, 501, 0, 4238, 4239, 3, 1019, 509, 0, 4239, 4240, 3, 1011, 505, 0, 4240, 744, 1, 0, 0, 0, 4241, 4242, 3, 983, 491, 0, 4242, 4243, 3, 1001, 500, 0, 4243, 4244, 3, 1015, 507, 0, 4244, 4245, 3, 999, 499, 0, 4245, 4246, 3, 983, 491, 0, 4246, 4247, 3, 1009, 504, 0, 4247, 4248, 3, 975, 487, 0, 4248, 4249, 3, 1013, 506, 0, 4249, 4250, 3, 991, 495, 0, 4250, 4251, 3, 1003, 501, 0, 4251, 4252, 3, 1001, 500, 0, 4252, 4253, 3, 1011, 505, 0, 4253, 746, 1, 0, 0, 0, 4254, 4255, 3, 979, 489, 0, 4255, 4256, 3, 1003, 501, 0, 4256, 4257, 3, 1001, 500, 0, 4257, 4258, 3, 1011, 505, 0, 4258, 4259, 3, 1013, 506, 0, 4259, 4260, 3, 975, 487, 0, 4260, 4261, 3, 1001, 500, 0, 4261, 4262, 3, 1013, 506, 0, 4262, 4263, 3, 1011, 505, 0, 4263, 748, 1, 0, 0, 0, 4264, 4265, 3, 979, 489, 0, 4265, 4266, 3, 1003, 501, 0, 4266, 4267, 3, 1001, 500, 0, 4267, 4268, 3, 1001, 500, 0, 4268, 4269, 3, 983, 491, 0, 4269, 4270, 3, 979, 489, 0, 4270, 4271, 3, 1013, 506, 0, 4271, 4272, 3, 991, 495, 0, 4272, 4273, 3, 1003, 501, 0, 4273, 4274, 3, 1001, 500, 0, 4274, 4275, 3, 1011, 505, 0, 4275, 750, 1, 0, 0, 0, 4276, 4277, 3, 981, 490, 0, 4277, 4278, 3, 983, 491, 0, 4278, 4279, 3, 985, 492, 0, 4279, 4280, 3, 991, 495, 0, 4280, 4281, 3, 1001, 500, 0, 4281, 4282, 3, 983, 491, 0, 4282, 752, 1, 0, 0, 0, 4283, 4284, 3, 985, 492, 0, 4284, 4285, 3, 1009, 504, 0, 4285, 4286, 3, 975, 487, 0, 4286, 4287, 3, 987, 493, 0, 4287, 4288, 3, 999, 499, 0, 4288, 4289, 3, 983, 491, 0, 4289, 4290, 3, 1001, 500, 0, 4290, 4291, 3, 1013, 506, 0, 4291, 754, 1, 0, 0, 0, 4292, 4293, 3, 985, 492, 0, 4293, 4294, 3, 1009, 504, 0, 4294, 4295, 3, 975, 487, 0, 4295, 4296, 3, 987, 493, 0, 4296, 4297, 3, 999, 499, 0, 4297, 4298, 3, 983, 491, 0, 4298, 4299, 3, 1001, 500, 0, 4299, 4300, 3, 1013, 506, 0, 4300, 4301, 3, 1011, 505, 0, 4301, 756, 1, 0, 0, 0, 4302, 4303, 3, 991, 495, 0, 4303, 4304, 3, 1001, 500, 0, 4304, 4305, 3, 1011, 505, 0, 4305, 4306, 3, 983, 491, 0, 4306, 4307, 3, 1009, 504, 0, 4307, 4308, 3, 1013, 506, 0, 4308, 758, 1, 0, 0, 0, 4309, 4310, 3, 977, 488, 0, 4310, 4311, 3, 983, 491, 0, 4311, 4312, 3, 985, 492, 0, 4312, 4313, 3, 1003, 501, 0, 4313, 4314, 3, 1009, 504, 0, 4314, 4315, 3, 983, 491, 0, 4315, 760, 1, 0, 0, 0, 4316, 4317, 3, 975, 487, 0, 4317, 4318, 3, 985, 492, 0, 4318, 4319, 3, 1013, 506, 0, 4319, 4320, 3, 983, 491, 0, 4320, 4321, 3, 1009, 504, 0, 4321, 762, 1, 0, 0, 0, 4322, 4323, 3, 1015, 507, 0, 4323, 4324, 3, 1005, 502, 0, 4324, 4325, 3, 981, 490, 0, 4325, 4326, 3, 975, 487, 0, 4326, 4327, 3, 1013, 506, 0, 4327, 4328, 3, 983, 491, 0, 4328, 764, 1, 0, 0, 0, 4329, 4330, 3, 1009, 504, 0, 4330, 4331, 3, 983, 491, 0, 4331, 4332, 3, 985, 492, 0, 4332, 4333, 3, 1009, 504, 0, 4333, 4334, 3, 983, 491, 0, 4334, 4335, 3, 1011, 505, 0, 4335, 4336, 3, 989, 494, 0, 4336, 766, 1, 0, 0, 0, 4337, 4338, 3, 979, 489, 0, 4338, 4339, 3, 989, 494, 0, 4339, 4340, 3, 983, 491, 0, 4340, 4341, 3, 979, 489, 0, 4341, 4342, 3, 995, 497, 0, 4342, 768, 1, 0, 0, 0, 4343, 4344, 3, 977, 488, 0, 4344, 4345, 3, 1015, 507, 0, 4345, 4346, 3, 991, 495, 0, 4346, 4347, 3, 997, 498, 0, 4347, 4348, 3, 981, 490, 0, 4348, 770, 1, 0, 0, 0, 4349, 4350, 3, 983, 491, 0, 4350, 4351, 3, 1021, 510, 0, 4351, 4352, 3, 983, 491, 0, 4352, 4353, 3, 979, 489, 0, 4353, 4354, 3, 1015, 507, 0, 4354, 4355, 3, 1013, 506, 0, 4355, 4356, 3, 983, 491, 0, 4356, 772, 1, 0, 0, 0, 4357, 4358, 3, 1011, 505, 0, 4358, 4359, 3, 979, 489, 0, 4359, 4360, 3, 1009, 504, 0, 4360, 4361, 3, 991, 495, 0, 4361, 4362, 3, 1005, 502, 0, 4362, 4363, 3, 1013, 506, 0, 4363, 774, 1, 0, 0, 0, 4364, 4365, 3, 997, 498, 0, 4365, 4366, 3, 991, 495, 0, 4366, 4367, 3, 1001, 500, 0, 4367, 4368, 3, 1013, 506, 0, 4368, 776, 1, 0, 0, 0, 4369, 4370, 3, 1009, 504, 0, 4370, 4371, 3, 1015, 507, 0, 4371, 4372, 3, 997, 498, 0, 4372, 4373, 3, 983, 491, 0, 4373, 4374, 3, 1011, 505, 0, 4374, 778, 1, 0, 0, 0, 4375, 4376, 3, 1013, 506, 0, 4376, 4377, 3, 983, 491, 0, 4377, 4378, 3, 1021, 510, 0, 4378, 4379, 3, 1013, 506, 0, 4379, 780, 1, 0, 0, 0, 4380, 4381, 3, 1011, 505, 0, 4381, 4382, 3, 975, 487, 0, 4382, 4383, 3, 1009, 504, 0, 4383, 4384, 3, 991, 495, 0, 4384, 4385, 3, 985, 492, 0, 4385, 782, 1, 0, 0, 0, 4386, 4387, 3, 999, 499, 0, 4387, 4388, 3, 983, 491, 0, 4388, 4389, 3, 1011, 505, 0, 4389, 4390, 3, 1011, 505, 0, 4390, 4391, 3, 975, 487, 0, 4391, 4392, 3, 987, 493, 0, 4392, 4393, 3, 983, 491, 0, 4393, 784, 1, 0, 0, 0, 4394, 4395, 3, 979, 489, 0, 4395, 4396, 3, 1003, 501, 0, 4396, 4397, 3, 999, 499, 0, 4397, 4398, 3, 999, 499, 0, 4398, 4399, 3, 983, 491, 0, 4399, 4400, 3, 1001, 500, 0, 4400, 4401, 3, 1013, 506, 0, 4401, 786, 1, 0, 0, 0, 4402, 4403, 3, 979, 489, 0, 4403, 4404, 3, 975, 487, 0, 4404, 4405, 3, 1013, 506, 0, 4405, 4406, 3, 975, 487, 0, 4406, 4407, 3, 997, 498, 0, 4407, 4408, 3, 1003, 501, 0, 4408, 4409, 3, 987, 493, 0, 4409, 788, 1, 0, 0, 0, 4410, 4411, 3, 985, 492, 0, 4411, 4412, 3, 1003, 501, 0, 4412, 4413, 3, 1009, 504, 0, 4413, 4414, 3, 979, 489, 0, 4414, 4415, 3, 983, 491, 0, 4415, 790, 1, 0, 0, 0, 4416, 4417, 3, 977, 488, 0, 4417, 4418, 3, 975, 487, 0, 4418, 4419, 3, 979, 489, 0, 4419, 4420, 3, 995, 497, 0, 4420, 4421, 3, 987, 493, 0, 4421, 4422, 3, 1009, 504, 0, 4422, 4423, 3, 1003, 501, 0, 4423, 4424, 3, 1015, 507, 0, 4424, 4425, 3, 1001, 500, 0, 4425, 4426, 3, 981, 490, 0, 4426, 792, 1, 0, 0, 0, 4427, 4428, 3, 979, 489, 0, 4428, 4429, 3, 975, 487, 0, 4429, 4430, 3, 997, 498, 0, 4430, 4431, 3, 997, 498, 0, 4431, 4432, 3, 983, 491, 0, 4432, 4433, 3, 1009, 504, 0, 4433, 4434, 3, 1011, 505, 0, 4434, 794, 1, 0, 0, 0, 4435, 4436, 3, 979, 489, 0, 4436, 4437, 3, 975, 487, 0, 4437, 4438, 3, 997, 498, 0, 4438, 4439, 3, 997, 498, 0, 4439, 4440, 3, 983, 491, 0, 4440, 4441, 3, 983, 491, 0, 4441, 4442, 3, 1011, 505, 0, 4442, 796, 1, 0, 0, 0, 4443, 4444, 3, 1009, 504, 0, 4444, 4445, 3, 983, 491, 0, 4445, 4446, 3, 985, 492, 0, 4446, 4447, 3, 983, 491, 0, 4447, 4448, 3, 1009, 504, 0, 4448, 4449, 3, 983, 491, 0, 4449, 4450, 3, 1001, 500, 0, 4450, 4451, 3, 979, 489, 0, 4451, 4452, 3, 983, 491, 0, 4452, 4453, 3, 1011, 505, 0, 4453, 798, 1, 0, 0, 0, 4454, 4455, 3, 1013, 506, 0, 4455, 4456, 3, 1009, 504, 0, 4456, 4457, 3, 975, 487, 0, 4457, 4458, 3, 1001, 500, 0, 4458, 4459, 3, 1011, 505, 0, 4459, 4460, 3, 991, 495, 0, 4460, 4461, 3, 1013, 506, 0, 4461, 4462, 3, 991, 495, 0, 4462, 4463, 3, 1017, 508, 0, 4463, 4464, 3, 983, 491, 0, 4464, 800, 1, 0, 0, 0, 4465, 4466, 3, 991, 495, 0, 4466, 4467, 3, 999, 499, 0, 4467, 4468, 3, 1005, 502, 0, 4468, 4469, 3, 975, 487, 0, 4469, 4470, 3, 979, 489, 0, 4470, 4471, 3, 1013, 506, 0, 4471, 802, 1, 0, 0, 0, 4472, 4473, 3, 981, 490, 0, 4473, 4474, 3, 983, 491, 0, 4474, 4475, 3, 1005, 502, 0, 4475, 4476, 3, 1013, 506, 0, 4476, 4477, 3, 989, 494, 0, 4477, 804, 1, 0, 0, 0, 4478, 4479, 3, 1011, 505, 0, 4479, 4480, 3, 1013, 506, 0, 4480, 4481, 3, 1009, 504, 0, 4481, 4482, 3, 1015, 507, 0, 4482, 4483, 3, 979, 489, 0, 4483, 4484, 3, 1013, 506, 0, 4484, 4485, 3, 1015, 507, 0, 4485, 4486, 3, 1009, 504, 0, 4486, 4487, 3, 983, 491, 0, 4487, 806, 1, 0, 0, 0, 4488, 4489, 3, 1013, 506, 0, 4489, 4490, 3, 1023, 511, 0, 4490, 4491, 3, 1005, 502, 0, 4491, 4492, 3, 983, 491, 0, 4492, 808, 1, 0, 0, 0, 4493, 4494, 3, 1017, 508, 0, 4494, 4495, 3, 975, 487, 0, 4495, 4496, 3, 997, 498, 0, 4496, 4497, 3, 1015, 507, 0, 4497, 4498, 3, 983, 491, 0, 4498, 810, 1, 0, 0, 0, 4499, 4500, 3, 1011, 505, 0, 4500, 4501, 3, 991, 495, 0, 4501, 4502, 3, 1001, 500, 0, 4502, 4503, 3, 987, 493, 0, 4503, 4504, 3, 997, 498, 0, 4504, 4505, 3, 983, 491, 0, 4505, 812, 1, 0, 0, 0, 4506, 4507, 3, 999, 499, 0, 4507, 4508, 3, 1015, 507, 0, 4508, 4509, 3, 997, 498, 0, 4509, 4510, 3, 1013, 506, 0, 4510, 4511, 3, 991, 495, 0, 4511, 4512, 3, 1005, 502, 0, 4512, 4513, 3, 997, 498, 0, 4513, 4514, 3, 983, 491, 0, 4514, 814, 1, 0, 0, 0, 4515, 4516, 3, 1001, 500, 0, 4516, 4517, 3, 1003, 501, 0, 4517, 4518, 3, 1001, 500, 0, 4518, 4519, 3, 983, 491, 0, 4519, 816, 1, 0, 0, 0, 4520, 4521, 3, 977, 488, 0, 4521, 4522, 3, 1003, 501, 0, 4522, 4523, 3, 1013, 506, 0, 4523, 4524, 3, 989, 494, 0, 4524, 818, 1, 0, 0, 0, 4525, 4526, 3, 1013, 506, 0, 4526, 4527, 3, 1003, 501, 0, 4527, 820, 1, 0, 0, 0, 4528, 4529, 3, 1003, 501, 0, 4529, 4530, 3, 985, 492, 0, 4530, 822, 1, 0, 0, 0, 4531, 4532, 3, 1003, 501, 0, 4532, 4533, 3, 1017, 508, 0, 4533, 4534, 3, 983, 491, 0, 4534, 4535, 3, 1009, 504, 0, 4535, 824, 1, 0, 0, 0, 4536, 4537, 3, 985, 492, 0, 4537, 4538, 3, 1003, 501, 0, 4538, 4539, 3, 1009, 504, 0, 4539, 826, 1, 0, 0, 0, 4540, 4541, 3, 1009, 504, 0, 4541, 4542, 3, 983, 491, 0, 4542, 4543, 3, 1005, 502, 0, 4543, 4544, 3, 997, 498, 0, 4544, 4545, 3, 975, 487, 0, 4545, 4546, 3, 979, 489, 0, 4546, 4547, 3, 983, 491, 0, 4547, 828, 1, 0, 0, 0, 4548, 4549, 3, 999, 499, 0, 4549, 4550, 3, 983, 491, 0, 4550, 4551, 3, 999, 499, 0, 4551, 4552, 3, 977, 488, 0, 4552, 4553, 3, 983, 491, 0, 4553, 4554, 3, 1009, 504, 0, 4554, 4555, 3, 1011, 505, 0, 4555, 830, 1, 0, 0, 0, 4556, 4557, 3, 975, 487, 0, 4557, 4558, 3, 1013, 506, 0, 4558, 4559, 3, 1013, 506, 0, 4559, 4560, 3, 1009, 504, 0, 4560, 4561, 3, 991, 495, 0, 4561, 4562, 3, 977, 488, 0, 4562, 4563, 3, 1015, 507, 0, 4563, 4564, 3, 1013, 506, 0, 4564, 4565, 3, 983, 491, 0, 4565, 4566, 3, 1001, 500, 0, 4566, 4567, 3, 975, 487, 0, 4567, 4568, 3, 999, 499, 0, 4568, 4569, 3, 983, 491, 0, 4569, 832, 1, 0, 0, 0, 4570, 4571, 3, 985, 492, 0, 4571, 4572, 3, 1003, 501, 0, 4572, 4573, 3, 1009, 504, 0, 4573, 4574, 3, 999, 499, 0, 4574, 4575, 3, 975, 487, 0, 4575, 4576, 3, 1013, 506, 0, 4576, 834, 1, 0, 0, 0, 4577, 4578, 3, 1011, 505, 0, 4578, 4579, 3, 1007, 503, 0, 4579, 4580, 3, 997, 498, 0, 4580, 836, 1, 0, 0, 0, 4581, 4582, 3, 1019, 509, 0, 4582, 4583, 3, 991, 495, 0, 4583, 4584, 3, 1013, 506, 0, 4584, 4585, 3, 989, 494, 0, 4585, 4586, 3, 1003, 501, 0, 4586, 4587, 3, 1015, 507, 0, 4587, 4588, 3, 1013, 506, 0, 4588, 838, 1, 0, 0, 0, 4589, 4590, 3, 981, 490, 0, 4590, 4591, 3, 1009, 504, 0, 4591, 4592, 3, 1023, 511, 0, 4592, 840, 1, 0, 0, 0, 4593, 4594, 3, 1009, 504, 0, 4594, 4595, 3, 1015, 507, 0, 4595, 4596, 3, 1001, 500, 0, 4596, 842, 1, 0, 0, 0, 4597, 4598, 3, 1019, 509, 0, 4598, 4599, 3, 991, 495, 0, 4599, 4600, 3, 981, 490, 0, 4600, 4601, 3, 987, 493, 0, 4601, 4602, 3, 983, 491, 0, 4602, 4603, 3, 1013, 506, 0, 4603, 4604, 3, 1013, 506, 0, 4604, 4605, 3, 1023, 511, 0, 4605, 4606, 3, 1005, 502, 0, 4606, 4607, 3, 983, 491, 0, 4607, 844, 1, 0, 0, 0, 4608, 4609, 3, 1017, 508, 0, 4609, 4610, 5, 51, 0, 0, 4610, 846, 1, 0, 0, 0, 4611, 4612, 3, 977, 488, 0, 4612, 4613, 3, 1015, 507, 0, 4613, 4614, 3, 1011, 505, 0, 4614, 4615, 3, 991, 495, 0, 4615, 4616, 3, 1001, 500, 0, 4616, 4617, 3, 983, 491, 0, 4617, 4618, 3, 1011, 505, 0, 4618, 4619, 3, 1011, 505, 0, 4619, 848, 1, 0, 0, 0, 4620, 4621, 3, 983, 491, 0, 4621, 4622, 3, 1017, 508, 0, 4622, 4623, 3, 983, 491, 0, 4623, 4624, 3, 1001, 500, 0, 4624, 4625, 3, 1013, 506, 0, 4625, 850, 1, 0, 0, 0, 4626, 4627, 3, 1011, 505, 0, 4627, 4628, 3, 1015, 507, 0, 4628, 4629, 3, 977, 488, 0, 4629, 4630, 3, 1011, 505, 0, 4630, 4631, 3, 979, 489, 0, 4631, 4632, 3, 1009, 504, 0, 4632, 4633, 3, 991, 495, 0, 4633, 4634, 3, 977, 488, 0, 4634, 4635, 3, 983, 491, 0, 4635, 852, 1, 0, 0, 0, 4636, 4637, 3, 1011, 505, 0, 4637, 4638, 3, 983, 491, 0, 4638, 4639, 3, 1013, 506, 0, 4639, 4640, 3, 1013, 506, 0, 4640, 4641, 3, 991, 495, 0, 4641, 4642, 3, 1001, 500, 0, 4642, 4643, 3, 987, 493, 0, 4643, 4644, 3, 1011, 505, 0, 4644, 854, 1, 0, 0, 0, 4645, 4646, 3, 979, 489, 0, 4646, 4647, 3, 1003, 501, 0, 4647, 4648, 3, 1001, 500, 0, 4648, 4649, 3, 985, 492, 0, 4649, 4650, 3, 991, 495, 0, 4650, 4651, 3, 987, 493, 0, 4651, 4652, 3, 1015, 507, 0, 4652, 4653, 3, 1009, 504, 0, 4653, 4654, 3, 975, 487, 0, 4654, 4655, 3, 1013, 506, 0, 4655, 4656, 3, 991, 495, 0, 4656, 4657, 3, 1003, 501, 0, 4657, 4658, 3, 1001, 500, 0, 4658, 856, 1, 0, 0, 0, 4659, 4660, 3, 1011, 505, 0, 4660, 4661, 3, 983, 491, 0, 4661, 4662, 3, 979, 489, 0, 4662, 4663, 3, 1015, 507, 0, 4663, 4664, 3, 1009, 504, 0, 4664, 4665, 3, 991, 495, 0, 4665, 4666, 3, 1013, 506, 0, 4666, 4667, 3, 1023, 511, 0, 4667, 858, 1, 0, 0, 0, 4668, 4669, 3, 1009, 504, 0, 4669, 4670, 3, 1003, 501, 0, 4670, 4671, 3, 997, 498, 0, 4671, 4672, 3, 983, 491, 0, 4672, 860, 1, 0, 0, 0, 4673, 4674, 3, 1009, 504, 0, 4674, 4675, 3, 1003, 501, 0, 4675, 4676, 3, 997, 498, 0, 4676, 4677, 3, 983, 491, 0, 4677, 4678, 3, 1011, 505, 0, 4678, 862, 1, 0, 0, 0, 4679, 4680, 3, 987, 493, 0, 4680, 4681, 3, 1009, 504, 0, 4681, 4682, 3, 975, 487, 0, 4682, 4683, 3, 1001, 500, 0, 4683, 4684, 3, 1013, 506, 0, 4684, 864, 1, 0, 0, 0, 4685, 4686, 3, 1009, 504, 0, 4686, 4687, 3, 983, 491, 0, 4687, 4688, 3, 1017, 508, 0, 4688, 4689, 3, 1003, 501, 0, 4689, 4690, 3, 995, 497, 0, 4690, 4691, 3, 983, 491, 0, 4691, 866, 1, 0, 0, 0, 4692, 4693, 3, 1005, 502, 0, 4693, 4694, 3, 1009, 504, 0, 4694, 4695, 3, 1003, 501, 0, 4695, 4696, 3, 981, 490, 0, 4696, 4697, 3, 1015, 507, 0, 4697, 4698, 3, 979, 489, 0, 4698, 4699, 3, 1013, 506, 0, 4699, 4700, 3, 991, 495, 0, 4700, 4701, 3, 1003, 501, 0, 4701, 4702, 3, 1001, 500, 0, 4702, 868, 1, 0, 0, 0, 4703, 4704, 3, 1005, 502, 0, 4704, 4705, 3, 1009, 504, 0, 4705, 4706, 3, 1003, 501, 0, 4706, 4707, 3, 1013, 506, 0, 4707, 4708, 3, 1003, 501, 0, 4708, 4709, 3, 1013, 506, 0, 4709, 4710, 3, 1023, 511, 0, 4710, 4711, 3, 1005, 502, 0, 4711, 4712, 3, 983, 491, 0, 4712, 870, 1, 0, 0, 0, 4713, 4714, 3, 999, 499, 0, 4714, 4715, 3, 975, 487, 0, 4715, 4716, 3, 1001, 500, 0, 4716, 4717, 3, 975, 487, 0, 4717, 4718, 3, 987, 493, 0, 4718, 4719, 3, 983, 491, 0, 4719, 872, 1, 0, 0, 0, 4720, 4721, 3, 981, 490, 0, 4721, 4722, 3, 983, 491, 0, 4722, 4723, 3, 999, 499, 0, 4723, 4724, 3, 1003, 501, 0, 4724, 874, 1, 0, 0, 0, 4725, 4726, 3, 999, 499, 0, 4726, 4727, 3, 975, 487, 0, 4727, 4728, 3, 1013, 506, 0, 4728, 4729, 3, 1009, 504, 0, 4729, 4730, 3, 991, 495, 0, 4730, 4731, 3, 1021, 510, 0, 4731, 876, 1, 0, 0, 0, 4732, 4733, 3, 975, 487, 0, 4733, 4734, 3, 1005, 502, 0, 4734, 4735, 3, 1005, 502, 0, 4735, 4736, 3, 997, 498, 0, 4736, 4737, 3, 1023, 511, 0, 4737, 878, 1, 0, 0, 0, 4738, 4739, 3, 975, 487, 0, 4739, 4740, 3, 979, 489, 0, 4740, 4741, 3, 979, 489, 0, 4741, 4742, 3, 983, 491, 0, 4742, 4743, 3, 1011, 505, 0, 4743, 4744, 3, 1011, 505, 0, 4744, 880, 1, 0, 0, 0, 4745, 4746, 3, 997, 498, 0, 4746, 4747, 3, 983, 491, 0, 4747, 4748, 3, 1017, 508, 0, 4748, 4749, 3, 983, 491, 0, 4749, 4750, 3, 997, 498, 0, 4750, 882, 1, 0, 0, 0, 4751, 4752, 3, 1015, 507, 0, 4752, 4753, 3, 1011, 505, 0, 4753, 4754, 3, 983, 491, 0, 4754, 4755, 3, 1009, 504, 0, 4755, 884, 1, 0, 0, 0, 4756, 4757, 3, 1009, 504, 0, 4757, 4758, 3, 983, 491, 0, 4758, 4759, 3, 975, 487, 0, 4759, 4760, 3, 981, 490, 0, 4760, 886, 1, 0, 0, 0, 4761, 4762, 3, 1019, 509, 0, 4762, 4763, 3, 1009, 504, 0, 4763, 4764, 3, 991, 495, 0, 4764, 4765, 3, 1013, 506, 0, 4765, 4766, 3, 983, 491, 0, 4766, 888, 1, 0, 0, 0, 4767, 4768, 3, 981, 490, 0, 4768, 4769, 3, 983, 491, 0, 4769, 4770, 3, 1011, 505, 0, 4770, 4771, 3, 979, 489, 0, 4771, 4772, 3, 1009, 504, 0, 4772, 4773, 3, 991, 495, 0, 4773, 4774, 3, 1005, 502, 0, 4774, 4775, 3, 1013, 506, 0, 4775, 4776, 3, 991, 495, 0, 4776, 4777, 3, 1003, 501, 0, 4777, 4778, 3, 1001, 500, 0, 4778, 890, 1, 0, 0, 0, 4779, 4780, 3, 1003, 501, 0, 4780, 4781, 3, 985, 492, 0, 4781, 4782, 3, 985, 492, 0, 4782, 892, 1, 0, 0, 0, 4783, 4784, 3, 1015, 507, 0, 4784, 4785, 3, 1011, 505, 0, 4785, 4786, 3, 983, 491, 0, 4786, 4787, 3, 1009, 504, 0, 4787, 4788, 3, 1011, 505, 0, 4788, 894, 1, 0, 0, 0, 4789, 4790, 5, 60, 0, 0, 4790, 4794, 5, 62, 0, 0, 4791, 4792, 5, 33, 0, 0, 4792, 4794, 5, 61, 0, 0, 4793, 4789, 1, 0, 0, 0, 4793, 4791, 1, 0, 0, 0, 4794, 896, 1, 0, 0, 0, 4795, 4796, 5, 60, 0, 0, 4796, 4797, 5, 61, 0, 0, 4797, 898, 1, 0, 0, 0, 4798, 4799, 5, 62, 0, 0, 4799, 4800, 5, 61, 0, 0, 4800, 900, 1, 0, 0, 0, 4801, 4802, 5, 61, 0, 0, 4802, 902, 1, 0, 0, 0, 4803, 4804, 5, 60, 0, 0, 4804, 904, 1, 0, 0, 0, 4805, 4806, 5, 62, 0, 0, 4806, 906, 1, 0, 0, 0, 4807, 4808, 5, 43, 0, 0, 4808, 908, 1, 0, 0, 0, 4809, 4810, 5, 45, 0, 0, 4810, 910, 1, 0, 0, 0, 4811, 4812, 5, 42, 0, 0, 4812, 912, 1, 0, 0, 0, 4813, 4814, 5, 47, 0, 0, 4814, 914, 1, 0, 0, 0, 4815, 4816, 5, 37, 0, 0, 4816, 916, 1, 0, 0, 0, 4817, 4818, 3, 999, 499, 0, 4818, 4819, 3, 1003, 501, 0, 4819, 4820, 3, 981, 490, 0, 4820, 918, 1, 0, 0, 0, 4821, 4822, 3, 981, 490, 0, 4822, 4823, 3, 991, 495, 0, 4823, 4824, 3, 1017, 508, 0, 4824, 920, 1, 0, 0, 0, 4825, 4826, 5, 59, 0, 0, 4826, 922, 1, 0, 0, 0, 4827, 4828, 5, 44, 0, 0, 4828, 924, 1, 0, 0, 0, 4829, 4830, 5, 46, 0, 0, 4830, 926, 1, 0, 0, 0, 4831, 4832, 5, 40, 0, 0, 4832, 928, 1, 0, 0, 0, 4833, 4834, 5, 41, 0, 0, 4834, 930, 1, 0, 0, 0, 4835, 4836, 5, 123, 0, 0, 4836, 932, 1, 0, 0, 0, 4837, 4838, 5, 125, 0, 0, 4838, 934, 1, 0, 0, 0, 4839, 4840, 5, 91, 0, 0, 4840, 936, 1, 0, 0, 0, 4841, 4842, 5, 93, 0, 0, 4842, 938, 1, 0, 0, 0, 4843, 4844, 5, 58, 0, 0, 4844, 940, 1, 0, 0, 0, 4845, 4846, 5, 64, 0, 0, 4846, 942, 1, 0, 0, 0, 4847, 4848, 5, 124, 0, 0, 4848, 944, 1, 0, 0, 0, 4849, 4850, 5, 58, 0, 0, 4850, 4851, 5, 58, 0, 0, 4851, 946, 1, 0, 0, 0, 4852, 4853, 5, 45, 0, 0, 4853, 4854, 5, 62, 0, 0, 4854, 948, 1, 0, 0, 0, 4855, 4856, 5, 63, 0, 0, 4856, 950, 1, 0, 0, 0, 4857, 4858, 5, 35, 0, 0, 4858, 952, 1, 0, 0, 0, 4859, 4860, 5, 91, 0, 0, 4860, 4861, 5, 37, 0, 0, 4861, 4865, 1, 0, 0, 0, 4862, 4864, 9, 0, 0, 0, 4863, 4862, 1, 0, 0, 0, 4864, 4867, 1, 0, 0, 0, 4865, 4866, 1, 0, 0, 0, 4865, 4863, 1, 0, 0, 0, 4866, 4868, 1, 0, 0, 0, 4867, 4865, 1, 0, 0, 0, 4868, 4869, 5, 37, 0, 0, 4869, 4870, 5, 93, 0, 0, 4870, 954, 1, 0, 0, 0, 4871, 4879, 5, 39, 0, 0, 4872, 4878, 8, 2, 0, 0, 4873, 4874, 5, 92, 0, 0, 4874, 4878, 9, 0, 0, 0, 4875, 4876, 5, 39, 0, 0, 4876, 4878, 5, 39, 0, 0, 4877, 4872, 1, 0, 0, 0, 4877, 4873, 1, 0, 0, 0, 4877, 4875, 1, 0, 0, 0, 4878, 4881, 1, 0, 0, 0, 4879, 4877, 1, 0, 0, 0, 4879, 4880, 1, 0, 0, 0, 4880, 4882, 1, 0, 0, 0, 4881, 4879, 1, 0, 0, 0, 4882, 4883, 5, 39, 0, 0, 4883, 956, 1, 0, 0, 0, 4884, 4885, 5, 36, 0, 0, 4885, 4886, 5, 36, 0, 0, 4886, 4890, 1, 0, 0, 0, 4887, 4889, 9, 0, 0, 0, 4888, 4887, 1, 0, 0, 0, 4889, 4892, 1, 0, 0, 0, 4890, 4891, 1, 0, 0, 0, 4890, 4888, 1, 0, 0, 0, 4891, 4893, 1, 0, 0, 0, 4892, 4890, 1, 0, 0, 0, 4893, 4894, 5, 36, 0, 0, 4894, 4895, 5, 36, 0, 0, 4895, 958, 1, 0, 0, 0, 4896, 4898, 5, 45, 0, 0, 4897, 4896, 1, 0, 0, 0, 4897, 4898, 1, 0, 0, 0, 4898, 4900, 1, 0, 0, 0, 4899, 4901, 3, 973, 486, 0, 4900, 4899, 1, 0, 0, 0, 4901, 4902, 1, 0, 0, 0, 4902, 4900, 1, 0, 0, 0, 4902, 4903, 1, 0, 0, 0, 4903, 4910, 1, 0, 0, 0, 4904, 4906, 5, 46, 0, 0, 4905, 4907, 3, 973, 486, 0, 4906, 4905, 1, 0, 0, 0, 4907, 4908, 1, 0, 0, 0, 4908, 4906, 1, 0, 0, 0, 4908, 4909, 1, 0, 0, 0, 4909, 4911, 1, 0, 0, 0, 4910, 4904, 1, 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, 4921, 1, 0, 0, 0, 4912, 4914, 7, 3, 0, 0, 4913, 4915, 7, 4, 0, 0, 4914, 4913, 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 4917, 1, 0, 0, 0, 4916, 4918, 3, 973, 486, 0, 4917, 4916, 1, 0, 0, 0, 4918, 4919, 1, 0, 0, 0, 4919, 4917, 1, 0, 0, 0, 4919, 4920, 1, 0, 0, 0, 4920, 4922, 1, 0, 0, 0, 4921, 4912, 1, 0, 0, 0, 4921, 4922, 1, 0, 0, 0, 4922, 960, 1, 0, 0, 0, 4923, 4925, 5, 36, 0, 0, 4924, 4926, 3, 971, 485, 0, 4925, 4924, 1, 0, 0, 0, 4926, 4927, 1, 0, 0, 0, 4927, 4925, 1, 0, 0, 0, 4927, 4928, 1, 0, 0, 0, 4928, 962, 1, 0, 0, 0, 4929, 4933, 3, 969, 484, 0, 4930, 4932, 3, 971, 485, 0, 4931, 4930, 1, 0, 0, 0, 4932, 4935, 1, 0, 0, 0, 4933, 4931, 1, 0, 0, 0, 4933, 4934, 1, 0, 0, 0, 4934, 964, 1, 0, 0, 0, 4935, 4933, 1, 0, 0, 0, 4936, 4944, 3, 969, 484, 0, 4937, 4939, 3, 971, 485, 0, 4938, 4937, 1, 0, 0, 0, 4939, 4942, 1, 0, 0, 0, 4940, 4938, 1, 0, 0, 0, 4940, 4941, 1, 0, 0, 0, 4941, 4943, 1, 0, 0, 0, 4942, 4940, 1, 0, 0, 0, 4943, 4945, 5, 45, 0, 0, 4944, 4940, 1, 0, 0, 0, 4945, 4946, 1, 0, 0, 0, 4946, 4944, 1, 0, 0, 0, 4946, 4947, 1, 0, 0, 0, 4947, 4951, 1, 0, 0, 0, 4948, 4950, 3, 971, 485, 0, 4949, 4948, 1, 0, 0, 0, 4950, 4953, 1, 0, 0, 0, 4951, 4949, 1, 0, 0, 0, 4951, 4952, 1, 0, 0, 0, 4952, 966, 1, 0, 0, 0, 4953, 4951, 1, 0, 0, 0, 4954, 4958, 5, 34, 0, 0, 4955, 4957, 8, 5, 0, 0, 4956, 4955, 1, 0, 0, 0, 4957, 4960, 1, 0, 0, 0, 4958, 4956, 1, 0, 0, 0, 4958, 4959, 1, 0, 0, 0, 4959, 4961, 1, 0, 0, 0, 4960, 4958, 1, 0, 0, 0, 4961, 4971, 5, 34, 0, 0, 4962, 4966, 5, 96, 0, 0, 4963, 4965, 8, 6, 0, 0, 4964, 4963, 1, 0, 0, 0, 4965, 4968, 1, 0, 0, 0, 4966, 4964, 1, 0, 0, 0, 4966, 4967, 1, 0, 0, 0, 4967, 4969, 1, 0, 0, 0, 4968, 4966, 1, 0, 0, 0, 4969, 4971, 5, 96, 0, 0, 4970, 4954, 1, 0, 0, 0, 4970, 4962, 1, 0, 0, 0, 4971, 968, 1, 0, 0, 0, 4972, 4973, 7, 7, 0, 0, 4973, 970, 1, 0, 0, 0, 4974, 4975, 7, 8, 0, 0, 4975, 972, 1, 0, 0, 0, 4976, 4977, 7, 9, 0, 0, 4977, 974, 1, 0, 0, 0, 4978, 4979, 7, 10, 0, 0, 4979, 976, 1, 0, 0, 0, 4980, 4981, 7, 11, 0, 0, 4981, 978, 1, 0, 0, 0, 4982, 4983, 7, 12, 0, 0, 4983, 980, 1, 0, 0, 0, 4984, 4985, 7, 13, 0, 0, 4985, 982, 1, 0, 0, 0, 4986, 4987, 7, 3, 0, 0, 4987, 984, 1, 0, 0, 0, 4988, 4989, 7, 14, 0, 0, 4989, 986, 1, 0, 0, 0, 4990, 4991, 7, 15, 0, 0, 4991, 988, 1, 0, 0, 0, 4992, 4993, 7, 16, 0, 0, 4993, 990, 1, 0, 0, 0, 4994, 4995, 7, 17, 0, 0, 4995, 992, 1, 0, 0, 0, 4996, 4997, 7, 18, 0, 0, 4997, 994, 1, 0, 0, 0, 4998, 4999, 7, 19, 0, 0, 4999, 996, 1, 0, 0, 0, 5000, 5001, 7, 20, 0, 0, 5001, 998, 1, 0, 0, 0, 5002, 5003, 7, 21, 0, 0, 5003, 1000, 1, 0, 0, 0, 5004, 5005, 7, 22, 0, 0, 5005, 1002, 1, 0, 0, 0, 5006, 5007, 7, 23, 0, 0, 5007, 1004, 1, 0, 0, 0, 5008, 5009, 7, 24, 0, 0, 5009, 1006, 1, 0, 0, 0, 5010, 5011, 7, 25, 0, 0, 5011, 1008, 1, 0, 0, 0, 5012, 5013, 7, 26, 0, 0, 5013, 1010, 1, 0, 0, 0, 5014, 5015, 7, 27, 0, 0, 5015, 1012, 1, 0, 0, 0, 5016, 5017, 7, 28, 0, 0, 5017, 1014, 1, 0, 0, 0, 5018, 5019, 7, 29, 0, 0, 5019, 1016, 1, 0, 0, 0, 5020, 5021, 7, 30, 0, 0, 5021, 1018, 1, 0, 0, 0, 5022, 5023, 7, 31, 0, 0, 5023, 1020, 1, 0, 0, 0, 5024, 5025, 7, 32, 0, 0, 5025, 1022, 1, 0, 0, 0, 5026, 5027, 7, 33, 0, 0, 5027, 1024, 1, 0, 0, 0, 5028, 5029, 7, 34, 0, 0, 5029, 1026, 1, 0, 0, 0, 46, 0, 1030, 1041, 1053, 1067, 1077, 1085, 1097, 1110, 1125, 1138, 1150, 1180, 1193, 1207, 1215, 1270, 1281, 1289, 1298, 1362, 1373, 1380, 1387, 1445, 1735, 4793, 4865, 4877, 4879, 4890, 4897, 4902, 4908, 4910, 4914, 4919, 4921, 4927, 4933, 4940, 4946, 4951, 4958, 4966, 4970, 1, 6, 0, 0] \ No newline at end of file +[4, 0, 505, 5232, 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, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 1, 0, 4, 0, 1071, 8, 0, 11, 0, 12, 0, 1072, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1082, 8, 1, 10, 1, 12, 1, 1085, 9, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 1094, 8, 2, 10, 2, 12, 2, 1097, 9, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 1108, 8, 3, 10, 3, 12, 3, 1111, 9, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 4, 4, 1118, 8, 4, 11, 4, 12, 4, 1119, 1, 4, 1, 4, 1, 4, 1, 4, 4, 4, 1126, 8, 4, 11, 4, 12, 4, 1127, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 4, 5, 1138, 8, 5, 11, 5, 12, 5, 1139, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 4, 6, 1151, 8, 6, 11, 6, 12, 6, 1152, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 4, 7, 1166, 8, 7, 11, 7, 12, 7, 1167, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 4, 8, 1179, 8, 8, 11, 8, 12, 8, 1180, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 4, 9, 1191, 8, 9, 11, 9, 12, 9, 1192, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1223, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 4, 12, 1234, 8, 12, 11, 12, 12, 12, 1235, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1248, 8, 13, 11, 13, 12, 13, 1249, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1256, 8, 13, 11, 13, 12, 13, 1257, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1313, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 4, 14, 1322, 8, 14, 11, 14, 12, 14, 1323, 1, 14, 1, 14, 1, 14, 1, 14, 4, 14, 1330, 8, 14, 11, 14, 12, 14, 1331, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 4, 14, 1339, 8, 14, 11, 14, 12, 14, 1340, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1405, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 4, 15, 1414, 8, 15, 11, 15, 12, 15, 1415, 1, 15, 1, 15, 1, 15, 4, 15, 1421, 8, 15, 11, 15, 12, 15, 1422, 1, 15, 1, 15, 1, 15, 4, 15, 1428, 8, 15, 11, 15, 12, 15, 1429, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1488, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1778, 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 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, 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, 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, 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, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 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, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 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, 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, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 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, 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, 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, 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, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 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, 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, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 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, 110, 1, 110, 1, 110, 1, 110, 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, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 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, 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, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 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, 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, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 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, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 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, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 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, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 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, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 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, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 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, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 461, 1, 461, 1, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 1, 466, 1, 466, 1, 466, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 4996, 8, 468, 1, 469, 1, 469, 1, 469, 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, 472, 1, 472, 1, 473, 1, 473, 1, 474, 1, 474, 1, 475, 1, 475, 1, 476, 1, 476, 1, 477, 1, 477, 1, 478, 1, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 1, 482, 1, 482, 1, 483, 1, 483, 1, 484, 1, 484, 1, 485, 1, 485, 1, 486, 1, 486, 1, 487, 1, 487, 1, 488, 1, 488, 1, 489, 1, 489, 1, 490, 1, 490, 1, 491, 1, 491, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 1, 494, 1, 494, 1, 494, 1, 495, 1, 495, 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, 5, 497, 5066, 8, 497, 10, 497, 12, 497, 5069, 9, 497, 1, 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 5, 498, 5080, 8, 498, 10, 498, 12, 498, 5083, 9, 498, 1, 498, 1, 498, 1, 499, 1, 499, 1, 499, 1, 499, 5, 499, 5091, 8, 499, 10, 499, 12, 499, 5094, 9, 499, 1, 499, 1, 499, 1, 499, 1, 500, 3, 500, 5100, 8, 500, 1, 500, 4, 500, 5103, 8, 500, 11, 500, 12, 500, 5104, 1, 500, 1, 500, 4, 500, 5109, 8, 500, 11, 500, 12, 500, 5110, 3, 500, 5113, 8, 500, 1, 500, 1, 500, 3, 500, 5117, 8, 500, 1, 500, 4, 500, 5120, 8, 500, 11, 500, 12, 500, 5121, 3, 500, 5124, 8, 500, 1, 501, 1, 501, 4, 501, 5128, 8, 501, 11, 501, 12, 501, 5129, 1, 502, 1, 502, 5, 502, 5134, 8, 502, 10, 502, 12, 502, 5137, 9, 502, 1, 503, 1, 503, 5, 503, 5141, 8, 503, 10, 503, 12, 503, 5144, 9, 503, 1, 503, 4, 503, 5147, 8, 503, 11, 503, 12, 503, 5148, 1, 503, 5, 503, 5152, 8, 503, 10, 503, 12, 503, 5155, 9, 503, 1, 504, 1, 504, 5, 504, 5159, 8, 504, 10, 504, 12, 504, 5162, 9, 504, 1, 504, 1, 504, 1, 504, 5, 504, 5167, 8, 504, 10, 504, 12, 504, 5170, 9, 504, 1, 504, 3, 504, 5173, 8, 504, 1, 505, 1, 505, 1, 506, 1, 506, 1, 507, 1, 507, 1, 508, 1, 508, 1, 509, 1, 509, 1, 510, 1, 510, 1, 511, 1, 511, 1, 512, 1, 512, 1, 513, 1, 513, 1, 514, 1, 514, 1, 515, 1, 515, 1, 516, 1, 516, 1, 517, 1, 517, 1, 518, 1, 518, 1, 519, 1, 519, 1, 520, 1, 520, 1, 521, 1, 521, 1, 522, 1, 522, 1, 523, 1, 523, 1, 524, 1, 524, 1, 525, 1, 525, 1, 526, 1, 526, 1, 527, 1, 527, 1, 528, 1, 528, 1, 529, 1, 529, 1, 530, 1, 530, 1, 531, 1, 531, 1, 532, 1, 532, 1, 533, 1, 533, 4, 1083, 1095, 5067, 5092, 0, 534, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, 255, 511, 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, 525, 263, 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, 270, 541, 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, 555, 278, 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, 285, 571, 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, 585, 293, 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, 300, 601, 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, 615, 308, 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, 315, 631, 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, 645, 323, 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, 330, 661, 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, 675, 338, 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, 345, 691, 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, 705, 353, 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, 360, 721, 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, 735, 368, 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, 375, 751, 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, 765, 383, 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, 779, 390, 781, 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, 397, 795, 398, 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, 809, 405, 811, 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, 412, 825, 413, 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, 839, 420, 841, 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, 427, 855, 428, 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, 869, 435, 871, 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, 442, 885, 443, 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, 899, 450, 901, 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, 457, 915, 458, 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, 929, 465, 931, 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, 472, 945, 473, 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, 959, 480, 961, 481, 963, 482, 965, 483, 967, 484, 969, 485, 971, 486, 973, 487, 975, 488, 977, 489, 979, 490, 981, 491, 983, 492, 985, 493, 987, 494, 989, 495, 991, 496, 993, 497, 995, 498, 997, 499, 999, 500, 1001, 501, 1003, 502, 1005, 503, 1007, 504, 1009, 505, 1011, 0, 1013, 0, 1015, 0, 1017, 0, 1019, 0, 1021, 0, 1023, 0, 1025, 0, 1027, 0, 1029, 0, 1031, 0, 1033, 0, 1035, 0, 1037, 0, 1039, 0, 1041, 0, 1043, 0, 1045, 0, 1047, 0, 1049, 0, 1051, 0, 1053, 0, 1055, 0, 1057, 0, 1059, 0, 1061, 0, 1063, 0, 1065, 0, 1067, 0, 1, 0, 35, 2, 0, 9, 13, 32, 32, 2, 0, 10, 10, 13, 13, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 3, 0, 10, 10, 13, 13, 34, 34, 3, 0, 10, 10, 13, 13, 96, 96, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1, 0, 48, 57, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 5251, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, 813, 1, 0, 0, 0, 0, 815, 1, 0, 0, 0, 0, 817, 1, 0, 0, 0, 0, 819, 1, 0, 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, 1, 0, 0, 0, 0, 829, 1, 0, 0, 0, 0, 831, 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, 0, 835, 1, 0, 0, 0, 0, 837, 1, 0, 0, 0, 0, 839, 1, 0, 0, 0, 0, 841, 1, 0, 0, 0, 0, 843, 1, 0, 0, 0, 0, 845, 1, 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, 849, 1, 0, 0, 0, 0, 851, 1, 0, 0, 0, 0, 853, 1, 0, 0, 0, 0, 855, 1, 0, 0, 0, 0, 857, 1, 0, 0, 0, 0, 859, 1, 0, 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, 1, 0, 0, 0, 0, 865, 1, 0, 0, 0, 0, 867, 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, 0, 871, 1, 0, 0, 0, 0, 873, 1, 0, 0, 0, 0, 875, 1, 0, 0, 0, 0, 877, 1, 0, 0, 0, 0, 879, 1, 0, 0, 0, 0, 881, 1, 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, 885, 1, 0, 0, 0, 0, 887, 1, 0, 0, 0, 0, 889, 1, 0, 0, 0, 0, 891, 1, 0, 0, 0, 0, 893, 1, 0, 0, 0, 0, 895, 1, 0, 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, 1, 0, 0, 0, 0, 901, 1, 0, 0, 0, 0, 903, 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, 0, 907, 1, 0, 0, 0, 0, 909, 1, 0, 0, 0, 0, 911, 1, 0, 0, 0, 0, 913, 1, 0, 0, 0, 0, 915, 1, 0, 0, 0, 0, 917, 1, 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, 921, 1, 0, 0, 0, 0, 923, 1, 0, 0, 0, 0, 925, 1, 0, 0, 0, 0, 927, 1, 0, 0, 0, 0, 929, 1, 0, 0, 0, 0, 931, 1, 0, 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, 1, 0, 0, 0, 0, 937, 1, 0, 0, 0, 0, 939, 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, 0, 943, 1, 0, 0, 0, 0, 945, 1, 0, 0, 0, 0, 947, 1, 0, 0, 0, 0, 949, 1, 0, 0, 0, 0, 951, 1, 0, 0, 0, 0, 953, 1, 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, 957, 1, 0, 0, 0, 0, 959, 1, 0, 0, 0, 0, 961, 1, 0, 0, 0, 0, 963, 1, 0, 0, 0, 0, 965, 1, 0, 0, 0, 0, 967, 1, 0, 0, 0, 0, 969, 1, 0, 0, 0, 0, 971, 1, 0, 0, 0, 0, 973, 1, 0, 0, 0, 0, 975, 1, 0, 0, 0, 0, 977, 1, 0, 0, 0, 0, 979, 1, 0, 0, 0, 0, 981, 1, 0, 0, 0, 0, 983, 1, 0, 0, 0, 0, 985, 1, 0, 0, 0, 0, 987, 1, 0, 0, 0, 0, 989, 1, 0, 0, 0, 0, 991, 1, 0, 0, 0, 0, 993, 1, 0, 0, 0, 0, 995, 1, 0, 0, 0, 0, 997, 1, 0, 0, 0, 0, 999, 1, 0, 0, 0, 0, 1001, 1, 0, 0, 0, 0, 1003, 1, 0, 0, 0, 0, 1005, 1, 0, 0, 0, 0, 1007, 1, 0, 0, 0, 0, 1009, 1, 0, 0, 0, 1, 1070, 1, 0, 0, 0, 3, 1076, 1, 0, 0, 0, 5, 1089, 1, 0, 0, 0, 7, 1103, 1, 0, 0, 0, 9, 1114, 1, 0, 0, 0, 11, 1134, 1, 0, 0, 0, 13, 1146, 1, 0, 0, 0, 15, 1159, 1, 0, 0, 0, 17, 1172, 1, 0, 0, 0, 19, 1185, 1, 0, 0, 0, 21, 1197, 1, 0, 0, 0, 23, 1212, 1, 0, 0, 0, 25, 1228, 1, 0, 0, 0, 27, 1312, 1, 0, 0, 0, 29, 1404, 1, 0, 0, 0, 31, 1487, 1, 0, 0, 0, 33, 1489, 1, 0, 0, 0, 35, 1496, 1, 0, 0, 0, 37, 1502, 1, 0, 0, 0, 39, 1507, 1, 0, 0, 0, 41, 1514, 1, 0, 0, 0, 43, 1519, 1, 0, 0, 0, 45, 1526, 1, 0, 0, 0, 47, 1533, 1, 0, 0, 0, 49, 1544, 1, 0, 0, 0, 51, 1549, 1, 0, 0, 0, 53, 1558, 1, 0, 0, 0, 55, 1570, 1, 0, 0, 0, 57, 1582, 1, 0, 0, 0, 59, 1589, 1, 0, 0, 0, 61, 1599, 1, 0, 0, 0, 63, 1608, 1, 0, 0, 0, 65, 1617, 1, 0, 0, 0, 67, 1622, 1, 0, 0, 0, 69, 1630, 1, 0, 0, 0, 71, 1637, 1, 0, 0, 0, 73, 1646, 1, 0, 0, 0, 75, 1655, 1, 0, 0, 0, 77, 1665, 1, 0, 0, 0, 79, 1672, 1, 0, 0, 0, 81, 1680, 1, 0, 0, 0, 83, 1686, 1, 0, 0, 0, 85, 1692, 1, 0, 0, 0, 87, 1702, 1, 0, 0, 0, 89, 1717, 1, 0, 0, 0, 91, 1725, 1, 0, 0, 0, 93, 1729, 1, 0, 0, 0, 95, 1733, 1, 0, 0, 0, 97, 1742, 1, 0, 0, 0, 99, 1756, 1, 0, 0, 0, 101, 1764, 1, 0, 0, 0, 103, 1770, 1, 0, 0, 0, 105, 1788, 1, 0, 0, 0, 107, 1796, 1, 0, 0, 0, 109, 1804, 1, 0, 0, 0, 111, 1812, 1, 0, 0, 0, 113, 1823, 1, 0, 0, 0, 115, 1829, 1, 0, 0, 0, 117, 1837, 1, 0, 0, 0, 119, 1845, 1, 0, 0, 0, 121, 1852, 1, 0, 0, 0, 123, 1858, 1, 0, 0, 0, 125, 1863, 1, 0, 0, 0, 127, 1868, 1, 0, 0, 0, 129, 1873, 1, 0, 0, 0, 131, 1882, 1, 0, 0, 0, 133, 1886, 1, 0, 0, 0, 135, 1897, 1, 0, 0, 0, 137, 1903, 1, 0, 0, 0, 139, 1910, 1, 0, 0, 0, 141, 1915, 1, 0, 0, 0, 143, 1921, 1, 0, 0, 0, 145, 1928, 1, 0, 0, 0, 147, 1935, 1, 0, 0, 0, 149, 1941, 1, 0, 0, 0, 151, 1944, 1, 0, 0, 0, 153, 1952, 1, 0, 0, 0, 155, 1962, 1, 0, 0, 0, 157, 1967, 1, 0, 0, 0, 159, 1972, 1, 0, 0, 0, 161, 1977, 1, 0, 0, 0, 163, 1982, 1, 0, 0, 0, 165, 1986, 1, 0, 0, 0, 167, 1995, 1, 0, 0, 0, 169, 1999, 1, 0, 0, 0, 171, 2004, 1, 0, 0, 0, 173, 2009, 1, 0, 0, 0, 175, 2015, 1, 0, 0, 0, 177, 2021, 1, 0, 0, 0, 179, 2027, 1, 0, 0, 0, 181, 2032, 1, 0, 0, 0, 183, 2038, 1, 0, 0, 0, 185, 2041, 1, 0, 0, 0, 187, 2045, 1, 0, 0, 0, 189, 2050, 1, 0, 0, 0, 191, 2056, 1, 0, 0, 0, 193, 2064, 1, 0, 0, 0, 195, 2071, 1, 0, 0, 0, 197, 2080, 1, 0, 0, 0, 199, 2087, 1, 0, 0, 0, 201, 2094, 1, 0, 0, 0, 203, 2103, 1, 0, 0, 0, 205, 2108, 1, 0, 0, 0, 207, 2114, 1, 0, 0, 0, 209, 2117, 1, 0, 0, 0, 211, 2123, 1, 0, 0, 0, 213, 2130, 1, 0, 0, 0, 215, 2139, 1, 0, 0, 0, 217, 2145, 1, 0, 0, 0, 219, 2152, 1, 0, 0, 0, 221, 2158, 1, 0, 0, 0, 223, 2162, 1, 0, 0, 0, 225, 2167, 1, 0, 0, 0, 227, 2172, 1, 0, 0, 0, 229, 2179, 1, 0, 0, 0, 231, 2187, 1, 0, 0, 0, 233, 2193, 1, 0, 0, 0, 235, 2198, 1, 0, 0, 0, 237, 2205, 1, 0, 0, 0, 239, 2210, 1, 0, 0, 0, 241, 2215, 1, 0, 0, 0, 243, 2220, 1, 0, 0, 0, 245, 2225, 1, 0, 0, 0, 247, 2231, 1, 0, 0, 0, 249, 2241, 1, 0, 0, 0, 251, 2250, 1, 0, 0, 0, 253, 2259, 1, 0, 0, 0, 255, 2267, 1, 0, 0, 0, 257, 2275, 1, 0, 0, 0, 259, 2283, 1, 0, 0, 0, 261, 2288, 1, 0, 0, 0, 263, 2295, 1, 0, 0, 0, 265, 2302, 1, 0, 0, 0, 267, 2307, 1, 0, 0, 0, 269, 2315, 1, 0, 0, 0, 271, 2321, 1, 0, 0, 0, 273, 2330, 1, 0, 0, 0, 275, 2335, 1, 0, 0, 0, 277, 2341, 1, 0, 0, 0, 279, 2348, 1, 0, 0, 0, 281, 2356, 1, 0, 0, 0, 283, 2362, 1, 0, 0, 0, 285, 2370, 1, 0, 0, 0, 287, 2379, 1, 0, 0, 0, 289, 2389, 1, 0, 0, 0, 291, 2401, 1, 0, 0, 0, 293, 2413, 1, 0, 0, 0, 295, 2424, 1, 0, 0, 0, 297, 2433, 1, 0, 0, 0, 299, 2442, 1, 0, 0, 0, 301, 2451, 1, 0, 0, 0, 303, 2459, 1, 0, 0, 0, 305, 2469, 1, 0, 0, 0, 307, 2473, 1, 0, 0, 0, 309, 2478, 1, 0, 0, 0, 311, 2489, 1, 0, 0, 0, 313, 2496, 1, 0, 0, 0, 315, 2506, 1, 0, 0, 0, 317, 2521, 1, 0, 0, 0, 319, 2534, 1, 0, 0, 0, 321, 2545, 1, 0, 0, 0, 323, 2552, 1, 0, 0, 0, 325, 2558, 1, 0, 0, 0, 327, 2570, 1, 0, 0, 0, 329, 2578, 1, 0, 0, 0, 331, 2589, 1, 0, 0, 0, 333, 2595, 1, 0, 0, 0, 335, 2603, 1, 0, 0, 0, 337, 2612, 1, 0, 0, 0, 339, 2623, 1, 0, 0, 0, 341, 2636, 1, 0, 0, 0, 343, 2645, 1, 0, 0, 0, 345, 2654, 1, 0, 0, 0, 347, 2663, 1, 0, 0, 0, 349, 2681, 1, 0, 0, 0, 351, 2707, 1, 0, 0, 0, 353, 2717, 1, 0, 0, 0, 355, 2728, 1, 0, 0, 0, 357, 2741, 1, 0, 0, 0, 359, 2752, 1, 0, 0, 0, 361, 2765, 1, 0, 0, 0, 363, 2780, 1, 0, 0, 0, 365, 2791, 1, 0, 0, 0, 367, 2798, 1, 0, 0, 0, 369, 2805, 1, 0, 0, 0, 371, 2813, 1, 0, 0, 0, 373, 2821, 1, 0, 0, 0, 375, 2826, 1, 0, 0, 0, 377, 2834, 1, 0, 0, 0, 379, 2845, 1, 0, 0, 0, 381, 2852, 1, 0, 0, 0, 383, 2862, 1, 0, 0, 0, 385, 2869, 1, 0, 0, 0, 387, 2876, 1, 0, 0, 0, 389, 2884, 1, 0, 0, 0, 391, 2895, 1, 0, 0, 0, 393, 2901, 1, 0, 0, 0, 395, 2906, 1, 0, 0, 0, 397, 2920, 1, 0, 0, 0, 399, 2934, 1, 0, 0, 0, 401, 2941, 1, 0, 0, 0, 403, 2951, 1, 0, 0, 0, 405, 2964, 1, 0, 0, 0, 407, 2970, 1, 0, 0, 0, 409, 2976, 1, 0, 0, 0, 411, 2988, 1, 0, 0, 0, 413, 2995, 1, 0, 0, 0, 415, 3006, 1, 0, 0, 0, 417, 3023, 1, 0, 0, 0, 419, 3031, 1, 0, 0, 0, 421, 3037, 1, 0, 0, 0, 423, 3043, 1, 0, 0, 0, 425, 3050, 1, 0, 0, 0, 427, 3059, 1, 0, 0, 0, 429, 3063, 1, 0, 0, 0, 431, 3070, 1, 0, 0, 0, 433, 3078, 1, 0, 0, 0, 435, 3086, 1, 0, 0, 0, 437, 3095, 1, 0, 0, 0, 439, 3104, 1, 0, 0, 0, 441, 3115, 1, 0, 0, 0, 443, 3126, 1, 0, 0, 0, 445, 3132, 1, 0, 0, 0, 447, 3144, 1, 0, 0, 0, 449, 3157, 1, 0, 0, 0, 451, 3173, 1, 0, 0, 0, 453, 3182, 1, 0, 0, 0, 455, 3190, 1, 0, 0, 0, 457, 3202, 1, 0, 0, 0, 459, 3215, 1, 0, 0, 0, 461, 3230, 1, 0, 0, 0, 463, 3241, 1, 0, 0, 0, 465, 3251, 1, 0, 0, 0, 467, 3265, 1, 0, 0, 0, 469, 3279, 1, 0, 0, 0, 471, 3293, 1, 0, 0, 0, 473, 3308, 1, 0, 0, 0, 475, 3322, 1, 0, 0, 0, 477, 3332, 1, 0, 0, 0, 479, 3341, 1, 0, 0, 0, 481, 3348, 1, 0, 0, 0, 483, 3356, 1, 0, 0, 0, 485, 3364, 1, 0, 0, 0, 487, 3371, 1, 0, 0, 0, 489, 3379, 1, 0, 0, 0, 491, 3384, 1, 0, 0, 0, 493, 3393, 1, 0, 0, 0, 495, 3401, 1, 0, 0, 0, 497, 3410, 1, 0, 0, 0, 499, 3419, 1, 0, 0, 0, 501, 3422, 1, 0, 0, 0, 503, 3425, 1, 0, 0, 0, 505, 3428, 1, 0, 0, 0, 507, 3431, 1, 0, 0, 0, 509, 3434, 1, 0, 0, 0, 511, 3437, 1, 0, 0, 0, 513, 3447, 1, 0, 0, 0, 515, 3454, 1, 0, 0, 0, 517, 3462, 1, 0, 0, 0, 519, 3467, 1, 0, 0, 0, 521, 3475, 1, 0, 0, 0, 523, 3483, 1, 0, 0, 0, 525, 3492, 1, 0, 0, 0, 527, 3497, 1, 0, 0, 0, 529, 3508, 1, 0, 0, 0, 531, 3515, 1, 0, 0, 0, 533, 3528, 1, 0, 0, 0, 535, 3537, 1, 0, 0, 0, 537, 3543, 1, 0, 0, 0, 539, 3558, 1, 0, 0, 0, 541, 3563, 1, 0, 0, 0, 543, 3569, 1, 0, 0, 0, 545, 3573, 1, 0, 0, 0, 547, 3577, 1, 0, 0, 0, 549, 3581, 1, 0, 0, 0, 551, 3585, 1, 0, 0, 0, 553, 3592, 1, 0, 0, 0, 555, 3597, 1, 0, 0, 0, 557, 3606, 1, 0, 0, 0, 559, 3611, 1, 0, 0, 0, 561, 3615, 1, 0, 0, 0, 563, 3618, 1, 0, 0, 0, 565, 3622, 1, 0, 0, 0, 567, 3627, 1, 0, 0, 0, 569, 3630, 1, 0, 0, 0, 571, 3638, 1, 0, 0, 0, 573, 3643, 1, 0, 0, 0, 575, 3649, 1, 0, 0, 0, 577, 3656, 1, 0, 0, 0, 579, 3663, 1, 0, 0, 0, 581, 3671, 1, 0, 0, 0, 583, 3676, 1, 0, 0, 0, 585, 3682, 1, 0, 0, 0, 587, 3693, 1, 0, 0, 0, 589, 3702, 1, 0, 0, 0, 591, 3707, 1, 0, 0, 0, 593, 3716, 1, 0, 0, 0, 595, 3722, 1, 0, 0, 0, 597, 3728, 1, 0, 0, 0, 599, 3734, 1, 0, 0, 0, 601, 3740, 1, 0, 0, 0, 603, 3748, 1, 0, 0, 0, 605, 3759, 1, 0, 0, 0, 607, 3765, 1, 0, 0, 0, 609, 3776, 1, 0, 0, 0, 611, 3787, 1, 0, 0, 0, 613, 3792, 1, 0, 0, 0, 615, 3800, 1, 0, 0, 0, 617, 3809, 1, 0, 0, 0, 619, 3815, 1, 0, 0, 0, 621, 3820, 1, 0, 0, 0, 623, 3825, 1, 0, 0, 0, 625, 3840, 1, 0, 0, 0, 627, 3846, 1, 0, 0, 0, 629, 3854, 1, 0, 0, 0, 631, 3860, 1, 0, 0, 0, 633, 3870, 1, 0, 0, 0, 635, 3877, 1, 0, 0, 0, 637, 3882, 1, 0, 0, 0, 639, 3890, 1, 0, 0, 0, 641, 3895, 1, 0, 0, 0, 643, 3904, 1, 0, 0, 0, 645, 3912, 1, 0, 0, 0, 647, 3917, 1, 0, 0, 0, 649, 3921, 1, 0, 0, 0, 651, 3928, 1, 0, 0, 0, 653, 3936, 1, 0, 0, 0, 655, 3940, 1, 0, 0, 0, 657, 3945, 1, 0, 0, 0, 659, 3949, 1, 0, 0, 0, 661, 3955, 1, 0, 0, 0, 663, 3959, 1, 0, 0, 0, 665, 3966, 1, 0, 0, 0, 667, 3974, 1, 0, 0, 0, 669, 3982, 1, 0, 0, 0, 671, 3989, 1, 0, 0, 0, 673, 3999, 1, 0, 0, 0, 675, 4007, 1, 0, 0, 0, 677, 4013, 1, 0, 0, 0, 679, 4020, 1, 0, 0, 0, 681, 4034, 1, 0, 0, 0, 683, 4043, 1, 0, 0, 0, 685, 4052, 1, 0, 0, 0, 687, 4063, 1, 0, 0, 0, 689, 4072, 1, 0, 0, 0, 691, 4078, 1, 0, 0, 0, 693, 4082, 1, 0, 0, 0, 695, 4090, 1, 0, 0, 0, 697, 4097, 1, 0, 0, 0, 699, 4102, 1, 0, 0, 0, 701, 4108, 1, 0, 0, 0, 703, 4113, 1, 0, 0, 0, 705, 4120, 1, 0, 0, 0, 707, 4129, 1, 0, 0, 0, 709, 4139, 1, 0, 0, 0, 711, 4144, 1, 0, 0, 0, 713, 4151, 1, 0, 0, 0, 715, 4157, 1, 0, 0, 0, 717, 4165, 1, 0, 0, 0, 719, 4175, 1, 0, 0, 0, 721, 4186, 1, 0, 0, 0, 723, 4194, 1, 0, 0, 0, 725, 4205, 1, 0, 0, 0, 727, 4210, 1, 0, 0, 0, 729, 4216, 1, 0, 0, 0, 731, 4221, 1, 0, 0, 0, 733, 4227, 1, 0, 0, 0, 735, 4233, 1, 0, 0, 0, 737, 4241, 1, 0, 0, 0, 739, 4250, 1, 0, 0, 0, 741, 4263, 1, 0, 0, 0, 743, 4274, 1, 0, 0, 0, 745, 4284, 1, 0, 0, 0, 747, 4294, 1, 0, 0, 0, 749, 4307, 1, 0, 0, 0, 751, 4317, 1, 0, 0, 0, 753, 4329, 1, 0, 0, 0, 755, 4336, 1, 0, 0, 0, 757, 4345, 1, 0, 0, 0, 759, 4355, 1, 0, 0, 0, 761, 4362, 1, 0, 0, 0, 763, 4369, 1, 0, 0, 0, 765, 4375, 1, 0, 0, 0, 767, 4382, 1, 0, 0, 0, 769, 4390, 1, 0, 0, 0, 771, 4396, 1, 0, 0, 0, 773, 4402, 1, 0, 0, 0, 775, 4410, 1, 0, 0, 0, 777, 4417, 1, 0, 0, 0, 779, 4422, 1, 0, 0, 0, 781, 4428, 1, 0, 0, 0, 783, 4433, 1, 0, 0, 0, 785, 4439, 1, 0, 0, 0, 787, 4447, 1, 0, 0, 0, 789, 4455, 1, 0, 0, 0, 791, 4463, 1, 0, 0, 0, 793, 4469, 1, 0, 0, 0, 795, 4480, 1, 0, 0, 0, 797, 4488, 1, 0, 0, 0, 799, 4496, 1, 0, 0, 0, 801, 4507, 1, 0, 0, 0, 803, 4518, 1, 0, 0, 0, 805, 4525, 1, 0, 0, 0, 807, 4531, 1, 0, 0, 0, 809, 4541, 1, 0, 0, 0, 811, 4546, 1, 0, 0, 0, 813, 4552, 1, 0, 0, 0, 815, 4559, 1, 0, 0, 0, 817, 4568, 1, 0, 0, 0, 819, 4573, 1, 0, 0, 0, 821, 4578, 1, 0, 0, 0, 823, 4581, 1, 0, 0, 0, 825, 4584, 1, 0, 0, 0, 827, 4589, 1, 0, 0, 0, 829, 4593, 1, 0, 0, 0, 831, 4601, 1, 0, 0, 0, 833, 4609, 1, 0, 0, 0, 835, 4623, 1, 0, 0, 0, 837, 4630, 1, 0, 0, 0, 839, 4634, 1, 0, 0, 0, 841, 4642, 1, 0, 0, 0, 843, 4646, 1, 0, 0, 0, 845, 4650, 1, 0, 0, 0, 847, 4661, 1, 0, 0, 0, 849, 4664, 1, 0, 0, 0, 851, 4673, 1, 0, 0, 0, 853, 4679, 1, 0, 0, 0, 855, 4689, 1, 0, 0, 0, 857, 4698, 1, 0, 0, 0, 859, 4712, 1, 0, 0, 0, 861, 4721, 1, 0, 0, 0, 863, 4726, 1, 0, 0, 0, 865, 4732, 1, 0, 0, 0, 867, 4738, 1, 0, 0, 0, 869, 4745, 1, 0, 0, 0, 871, 4756, 1, 0, 0, 0, 873, 4766, 1, 0, 0, 0, 875, 4773, 1, 0, 0, 0, 877, 4778, 1, 0, 0, 0, 879, 4785, 1, 0, 0, 0, 881, 4791, 1, 0, 0, 0, 883, 4798, 1, 0, 0, 0, 885, 4804, 1, 0, 0, 0, 887, 4809, 1, 0, 0, 0, 889, 4814, 1, 0, 0, 0, 891, 4823, 1, 0, 0, 0, 893, 4829, 1, 0, 0, 0, 895, 4838, 1, 0, 0, 0, 897, 4848, 1, 0, 0, 0, 899, 4861, 1, 0, 0, 0, 901, 4867, 1, 0, 0, 0, 903, 4872, 1, 0, 0, 0, 905, 4876, 1, 0, 0, 0, 907, 4885, 1, 0, 0, 0, 909, 4890, 1, 0, 0, 0, 911, 4899, 1, 0, 0, 0, 913, 4904, 1, 0, 0, 0, 915, 4915, 1, 0, 0, 0, 917, 4924, 1, 0, 0, 0, 919, 4937, 1, 0, 0, 0, 921, 4941, 1, 0, 0, 0, 923, 4947, 1, 0, 0, 0, 925, 4950, 1, 0, 0, 0, 927, 4955, 1, 0, 0, 0, 929, 4961, 1, 0, 0, 0, 931, 4973, 1, 0, 0, 0, 933, 4981, 1, 0, 0, 0, 935, 4985, 1, 0, 0, 0, 937, 4995, 1, 0, 0, 0, 939, 4997, 1, 0, 0, 0, 941, 5000, 1, 0, 0, 0, 943, 5003, 1, 0, 0, 0, 945, 5005, 1, 0, 0, 0, 947, 5007, 1, 0, 0, 0, 949, 5009, 1, 0, 0, 0, 951, 5011, 1, 0, 0, 0, 953, 5013, 1, 0, 0, 0, 955, 5015, 1, 0, 0, 0, 957, 5017, 1, 0, 0, 0, 959, 5019, 1, 0, 0, 0, 961, 5023, 1, 0, 0, 0, 963, 5027, 1, 0, 0, 0, 965, 5029, 1, 0, 0, 0, 967, 5031, 1, 0, 0, 0, 969, 5033, 1, 0, 0, 0, 971, 5035, 1, 0, 0, 0, 973, 5037, 1, 0, 0, 0, 975, 5039, 1, 0, 0, 0, 977, 5041, 1, 0, 0, 0, 979, 5043, 1, 0, 0, 0, 981, 5045, 1, 0, 0, 0, 983, 5047, 1, 0, 0, 0, 985, 5049, 1, 0, 0, 0, 987, 5051, 1, 0, 0, 0, 989, 5054, 1, 0, 0, 0, 991, 5057, 1, 0, 0, 0, 993, 5059, 1, 0, 0, 0, 995, 5061, 1, 0, 0, 0, 997, 5073, 1, 0, 0, 0, 999, 5086, 1, 0, 0, 0, 1001, 5099, 1, 0, 0, 0, 1003, 5125, 1, 0, 0, 0, 1005, 5131, 1, 0, 0, 0, 1007, 5138, 1, 0, 0, 0, 1009, 5172, 1, 0, 0, 0, 1011, 5174, 1, 0, 0, 0, 1013, 5176, 1, 0, 0, 0, 1015, 5178, 1, 0, 0, 0, 1017, 5180, 1, 0, 0, 0, 1019, 5182, 1, 0, 0, 0, 1021, 5184, 1, 0, 0, 0, 1023, 5186, 1, 0, 0, 0, 1025, 5188, 1, 0, 0, 0, 1027, 5190, 1, 0, 0, 0, 1029, 5192, 1, 0, 0, 0, 1031, 5194, 1, 0, 0, 0, 1033, 5196, 1, 0, 0, 0, 1035, 5198, 1, 0, 0, 0, 1037, 5200, 1, 0, 0, 0, 1039, 5202, 1, 0, 0, 0, 1041, 5204, 1, 0, 0, 0, 1043, 5206, 1, 0, 0, 0, 1045, 5208, 1, 0, 0, 0, 1047, 5210, 1, 0, 0, 0, 1049, 5212, 1, 0, 0, 0, 1051, 5214, 1, 0, 0, 0, 1053, 5216, 1, 0, 0, 0, 1055, 5218, 1, 0, 0, 0, 1057, 5220, 1, 0, 0, 0, 1059, 5222, 1, 0, 0, 0, 1061, 5224, 1, 0, 0, 0, 1063, 5226, 1, 0, 0, 0, 1065, 5228, 1, 0, 0, 0, 1067, 5230, 1, 0, 0, 0, 1069, 1071, 7, 0, 0, 0, 1070, 1069, 1, 0, 0, 0, 1071, 1072, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1072, 1073, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1075, 6, 0, 0, 0, 1075, 2, 1, 0, 0, 0, 1076, 1077, 5, 47, 0, 0, 1077, 1078, 5, 42, 0, 0, 1078, 1079, 5, 42, 0, 0, 1079, 1083, 1, 0, 0, 0, 1080, 1082, 9, 0, 0, 0, 1081, 1080, 1, 0, 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1083, 1081, 1, 0, 0, 0, 1084, 1086, 1, 0, 0, 0, 1085, 1083, 1, 0, 0, 0, 1086, 1087, 5, 42, 0, 0, 1087, 1088, 5, 47, 0, 0, 1088, 4, 1, 0, 0, 0, 1089, 1090, 5, 47, 0, 0, 1090, 1091, 5, 42, 0, 0, 1091, 1095, 1, 0, 0, 0, 1092, 1094, 9, 0, 0, 0, 1093, 1092, 1, 0, 0, 0, 1094, 1097, 1, 0, 0, 0, 1095, 1096, 1, 0, 0, 0, 1095, 1093, 1, 0, 0, 0, 1096, 1098, 1, 0, 0, 0, 1097, 1095, 1, 0, 0, 0, 1098, 1099, 5, 42, 0, 0, 1099, 1100, 5, 47, 0, 0, 1100, 1101, 1, 0, 0, 0, 1101, 1102, 6, 2, 0, 0, 1102, 6, 1, 0, 0, 0, 1103, 1104, 5, 45, 0, 0, 1104, 1105, 5, 45, 0, 0, 1105, 1109, 1, 0, 0, 0, 1106, 1108, 8, 1, 0, 0, 1107, 1106, 1, 0, 0, 0, 1108, 1111, 1, 0, 0, 0, 1109, 1107, 1, 0, 0, 0, 1109, 1110, 1, 0, 0, 0, 1110, 1112, 1, 0, 0, 0, 1111, 1109, 1, 0, 0, 0, 1112, 1113, 6, 3, 0, 0, 1113, 8, 1, 0, 0, 0, 1114, 1115, 3, 1033, 516, 0, 1115, 1117, 3, 1053, 526, 0, 1116, 1118, 3, 1, 0, 0, 1117, 1116, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1117, 1, 0, 0, 0, 1119, 1120, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1122, 3, 1043, 521, 0, 1122, 1123, 3, 1045, 522, 0, 1123, 1125, 3, 1055, 527, 0, 1124, 1126, 3, 1, 0, 0, 1125, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1125, 1, 0, 0, 0, 1127, 1128, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 1130, 3, 1043, 521, 0, 1130, 1131, 3, 1057, 528, 0, 1131, 1132, 3, 1039, 519, 0, 1132, 1133, 3, 1039, 519, 0, 1133, 10, 1, 0, 0, 0, 1134, 1135, 3, 1033, 516, 0, 1135, 1137, 3, 1053, 526, 0, 1136, 1138, 3, 1, 0, 0, 1137, 1136, 1, 0, 0, 0, 1138, 1139, 1, 0, 0, 0, 1139, 1137, 1, 0, 0, 0, 1139, 1140, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1142, 3, 1043, 521, 0, 1142, 1143, 3, 1057, 528, 0, 1143, 1144, 3, 1039, 519, 0, 1144, 1145, 3, 1039, 519, 0, 1145, 12, 1, 0, 0, 0, 1146, 1147, 3, 1043, 521, 0, 1147, 1148, 3, 1045, 522, 0, 1148, 1150, 3, 1055, 527, 0, 1149, 1151, 3, 1, 0, 0, 1150, 1149, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1150, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1155, 3, 1043, 521, 0, 1155, 1156, 3, 1057, 528, 0, 1156, 1157, 3, 1039, 519, 0, 1157, 1158, 3, 1039, 519, 0, 1158, 14, 1, 0, 0, 0, 1159, 1160, 3, 1029, 514, 0, 1160, 1161, 3, 1051, 525, 0, 1161, 1162, 3, 1045, 522, 0, 1162, 1163, 3, 1057, 528, 0, 1163, 1165, 3, 1047, 523, 0, 1164, 1166, 3, 1, 0, 0, 1165, 1164, 1, 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1165, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1169, 1, 0, 0, 0, 1169, 1170, 3, 1019, 509, 0, 1170, 1171, 3, 1065, 532, 0, 1171, 16, 1, 0, 0, 0, 1172, 1173, 3, 1045, 522, 0, 1173, 1174, 3, 1051, 525, 0, 1174, 1175, 3, 1023, 511, 0, 1175, 1176, 3, 1025, 512, 0, 1176, 1178, 3, 1051, 525, 0, 1177, 1179, 3, 1, 0, 0, 1178, 1177, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1183, 3, 1019, 509, 0, 1183, 1184, 3, 1065, 532, 0, 1184, 18, 1, 0, 0, 0, 1185, 1186, 3, 1053, 526, 0, 1186, 1187, 3, 1045, 522, 0, 1187, 1188, 3, 1051, 525, 0, 1188, 1190, 3, 1055, 527, 0, 1189, 1191, 3, 1, 0, 0, 1190, 1189, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1195, 3, 1019, 509, 0, 1195, 1196, 3, 1065, 532, 0, 1196, 20, 1, 0, 0, 0, 1197, 1198, 3, 1043, 521, 0, 1198, 1199, 3, 1045, 522, 0, 1199, 1200, 3, 1043, 521, 0, 1200, 1201, 5, 45, 0, 0, 1201, 1202, 3, 1047, 523, 0, 1202, 1203, 3, 1025, 512, 0, 1203, 1204, 3, 1051, 525, 0, 1204, 1205, 3, 1053, 526, 0, 1205, 1206, 3, 1033, 516, 0, 1206, 1207, 3, 1053, 526, 0, 1207, 1208, 3, 1055, 527, 0, 1208, 1209, 3, 1025, 512, 0, 1209, 1210, 3, 1043, 521, 0, 1210, 1211, 3, 1055, 527, 0, 1211, 22, 1, 0, 0, 0, 1212, 1213, 3, 1051, 525, 0, 1213, 1214, 3, 1025, 512, 0, 1214, 1215, 3, 1027, 513, 0, 1215, 1216, 3, 1025, 512, 0, 1216, 1217, 3, 1051, 525, 0, 1217, 1218, 3, 1025, 512, 0, 1218, 1219, 3, 1043, 521, 0, 1219, 1220, 3, 1021, 510, 0, 1220, 1222, 3, 1025, 512, 0, 1221, 1223, 5, 95, 0, 0, 1222, 1221, 1, 0, 0, 0, 1222, 1223, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 1225, 3, 1053, 526, 0, 1225, 1226, 3, 1025, 512, 0, 1226, 1227, 3, 1055, 527, 0, 1227, 24, 1, 0, 0, 0, 1228, 1229, 3, 1039, 519, 0, 1229, 1230, 3, 1033, 516, 0, 1230, 1231, 3, 1053, 526, 0, 1231, 1233, 3, 1055, 527, 0, 1232, 1234, 3, 1, 0, 0, 1233, 1232, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1233, 1, 0, 0, 0, 1235, 1236, 1, 0, 0, 0, 1236, 1237, 1, 0, 0, 0, 1237, 1238, 3, 1045, 522, 0, 1238, 1239, 3, 1027, 513, 0, 1239, 26, 1, 0, 0, 0, 1240, 1241, 3, 1023, 511, 0, 1241, 1242, 3, 1025, 512, 0, 1242, 1243, 3, 1039, 519, 0, 1243, 1244, 3, 1025, 512, 0, 1244, 1245, 3, 1055, 527, 0, 1245, 1247, 3, 1025, 512, 0, 1246, 1248, 3, 1, 0, 0, 1247, 1246, 1, 0, 0, 0, 1248, 1249, 1, 0, 0, 0, 1249, 1247, 1, 0, 0, 0, 1249, 1250, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 1252, 3, 1017, 508, 0, 1252, 1253, 3, 1043, 521, 0, 1253, 1255, 3, 1023, 511, 0, 1254, 1256, 3, 1, 0, 0, 1255, 1254, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 1255, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1259, 1, 0, 0, 0, 1259, 1260, 3, 1051, 525, 0, 1260, 1261, 3, 1025, 512, 0, 1261, 1262, 3, 1027, 513, 0, 1262, 1263, 3, 1025, 512, 0, 1263, 1264, 3, 1051, 525, 0, 1264, 1265, 3, 1025, 512, 0, 1265, 1266, 3, 1043, 521, 0, 1266, 1267, 3, 1021, 510, 0, 1267, 1268, 3, 1025, 512, 0, 1268, 1269, 3, 1053, 526, 0, 1269, 1313, 1, 0, 0, 0, 1270, 1271, 3, 1023, 511, 0, 1271, 1272, 3, 1025, 512, 0, 1272, 1273, 3, 1039, 519, 0, 1273, 1274, 3, 1025, 512, 0, 1274, 1275, 3, 1055, 527, 0, 1275, 1276, 3, 1025, 512, 0, 1276, 1277, 5, 95, 0, 0, 1277, 1278, 3, 1017, 508, 0, 1278, 1279, 3, 1043, 521, 0, 1279, 1280, 3, 1023, 511, 0, 1280, 1281, 5, 95, 0, 0, 1281, 1282, 3, 1051, 525, 0, 1282, 1283, 3, 1025, 512, 0, 1283, 1284, 3, 1027, 513, 0, 1284, 1285, 3, 1025, 512, 0, 1285, 1286, 3, 1051, 525, 0, 1286, 1287, 3, 1025, 512, 0, 1287, 1288, 3, 1043, 521, 0, 1288, 1289, 3, 1021, 510, 0, 1289, 1290, 3, 1025, 512, 0, 1290, 1291, 3, 1053, 526, 0, 1291, 1313, 1, 0, 0, 0, 1292, 1293, 3, 1023, 511, 0, 1293, 1294, 3, 1025, 512, 0, 1294, 1295, 3, 1039, 519, 0, 1295, 1296, 3, 1025, 512, 0, 1296, 1297, 3, 1055, 527, 0, 1297, 1298, 3, 1025, 512, 0, 1298, 1299, 3, 1017, 508, 0, 1299, 1300, 3, 1043, 521, 0, 1300, 1301, 3, 1023, 511, 0, 1301, 1302, 3, 1051, 525, 0, 1302, 1303, 3, 1025, 512, 0, 1303, 1304, 3, 1027, 513, 0, 1304, 1305, 3, 1025, 512, 0, 1305, 1306, 3, 1051, 525, 0, 1306, 1307, 3, 1025, 512, 0, 1307, 1308, 3, 1043, 521, 0, 1308, 1309, 3, 1021, 510, 0, 1309, 1310, 3, 1025, 512, 0, 1310, 1311, 3, 1053, 526, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1240, 1, 0, 0, 0, 1312, 1270, 1, 0, 0, 0, 1312, 1292, 1, 0, 0, 0, 1313, 28, 1, 0, 0, 0, 1314, 1315, 3, 1023, 511, 0, 1315, 1316, 3, 1025, 512, 0, 1316, 1317, 3, 1039, 519, 0, 1317, 1318, 3, 1025, 512, 0, 1318, 1319, 3, 1055, 527, 0, 1319, 1321, 3, 1025, 512, 0, 1320, 1322, 3, 1, 0, 0, 1321, 1320, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1323, 1324, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 1326, 3, 1019, 509, 0, 1326, 1327, 3, 1057, 528, 0, 1327, 1329, 3, 1055, 527, 0, 1328, 1330, 3, 1, 0, 0, 1329, 1328, 1, 0, 0, 0, 1330, 1331, 1, 0, 0, 0, 1331, 1329, 1, 0, 0, 0, 1331, 1332, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1334, 3, 1037, 518, 0, 1334, 1335, 3, 1025, 512, 0, 1335, 1336, 3, 1025, 512, 0, 1336, 1338, 3, 1047, 523, 0, 1337, 1339, 3, 1, 0, 0, 1338, 1337, 1, 0, 0, 0, 1339, 1340, 1, 0, 0, 0, 1340, 1338, 1, 0, 0, 0, 1340, 1341, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1343, 3, 1051, 525, 0, 1343, 1344, 3, 1025, 512, 0, 1344, 1345, 3, 1027, 513, 0, 1345, 1346, 3, 1025, 512, 0, 1346, 1347, 3, 1051, 525, 0, 1347, 1348, 3, 1025, 512, 0, 1348, 1349, 3, 1043, 521, 0, 1349, 1350, 3, 1021, 510, 0, 1350, 1351, 3, 1025, 512, 0, 1351, 1352, 3, 1053, 526, 0, 1352, 1405, 1, 0, 0, 0, 1353, 1354, 3, 1023, 511, 0, 1354, 1355, 3, 1025, 512, 0, 1355, 1356, 3, 1039, 519, 0, 1356, 1357, 3, 1025, 512, 0, 1357, 1358, 3, 1055, 527, 0, 1358, 1359, 3, 1025, 512, 0, 1359, 1360, 5, 95, 0, 0, 1360, 1361, 3, 1019, 509, 0, 1361, 1362, 3, 1057, 528, 0, 1362, 1363, 3, 1055, 527, 0, 1363, 1364, 5, 95, 0, 0, 1364, 1365, 3, 1037, 518, 0, 1365, 1366, 3, 1025, 512, 0, 1366, 1367, 3, 1025, 512, 0, 1367, 1368, 3, 1047, 523, 0, 1368, 1369, 5, 95, 0, 0, 1369, 1370, 3, 1051, 525, 0, 1370, 1371, 3, 1025, 512, 0, 1371, 1372, 3, 1027, 513, 0, 1372, 1373, 3, 1025, 512, 0, 1373, 1374, 3, 1051, 525, 0, 1374, 1375, 3, 1025, 512, 0, 1375, 1376, 3, 1043, 521, 0, 1376, 1377, 3, 1021, 510, 0, 1377, 1378, 3, 1025, 512, 0, 1378, 1379, 3, 1053, 526, 0, 1379, 1405, 1, 0, 0, 0, 1380, 1381, 3, 1023, 511, 0, 1381, 1382, 3, 1025, 512, 0, 1382, 1383, 3, 1039, 519, 0, 1383, 1384, 3, 1025, 512, 0, 1384, 1385, 3, 1055, 527, 0, 1385, 1386, 3, 1025, 512, 0, 1386, 1387, 3, 1019, 509, 0, 1387, 1388, 3, 1057, 528, 0, 1388, 1389, 3, 1055, 527, 0, 1389, 1390, 3, 1037, 518, 0, 1390, 1391, 3, 1025, 512, 0, 1391, 1392, 3, 1025, 512, 0, 1392, 1393, 3, 1047, 523, 0, 1393, 1394, 3, 1051, 525, 0, 1394, 1395, 3, 1025, 512, 0, 1395, 1396, 3, 1027, 513, 0, 1396, 1397, 3, 1025, 512, 0, 1397, 1398, 3, 1051, 525, 0, 1398, 1399, 3, 1025, 512, 0, 1399, 1400, 3, 1043, 521, 0, 1400, 1401, 3, 1021, 510, 0, 1401, 1402, 3, 1025, 512, 0, 1402, 1403, 3, 1053, 526, 0, 1403, 1405, 1, 0, 0, 0, 1404, 1314, 1, 0, 0, 0, 1404, 1353, 1, 0, 0, 0, 1404, 1380, 1, 0, 0, 0, 1405, 30, 1, 0, 0, 0, 1406, 1407, 3, 1023, 511, 0, 1407, 1408, 3, 1025, 512, 0, 1408, 1409, 3, 1039, 519, 0, 1409, 1410, 3, 1025, 512, 0, 1410, 1411, 3, 1055, 527, 0, 1411, 1413, 3, 1025, 512, 0, 1412, 1414, 3, 1, 0, 0, 1413, 1412, 1, 0, 0, 0, 1414, 1415, 1, 0, 0, 0, 1415, 1413, 1, 0, 0, 0, 1415, 1416, 1, 0, 0, 0, 1416, 1417, 1, 0, 0, 0, 1417, 1418, 3, 1033, 516, 0, 1418, 1420, 3, 1027, 513, 0, 1419, 1421, 3, 1, 0, 0, 1420, 1419, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 1420, 1, 0, 0, 0, 1422, 1423, 1, 0, 0, 0, 1423, 1424, 1, 0, 0, 0, 1424, 1425, 3, 1043, 521, 0, 1425, 1427, 3, 1045, 522, 0, 1426, 1428, 3, 1, 0, 0, 1427, 1426, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 1427, 1, 0, 0, 0, 1429, 1430, 1, 0, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 1432, 3, 1051, 525, 0, 1432, 1433, 3, 1025, 512, 0, 1433, 1434, 3, 1027, 513, 0, 1434, 1435, 3, 1025, 512, 0, 1435, 1436, 3, 1051, 525, 0, 1436, 1437, 3, 1025, 512, 0, 1437, 1438, 3, 1043, 521, 0, 1438, 1439, 3, 1021, 510, 0, 1439, 1440, 3, 1025, 512, 0, 1440, 1441, 3, 1053, 526, 0, 1441, 1488, 1, 0, 0, 0, 1442, 1443, 3, 1023, 511, 0, 1443, 1444, 3, 1025, 512, 0, 1444, 1445, 3, 1039, 519, 0, 1445, 1446, 3, 1025, 512, 0, 1446, 1447, 3, 1055, 527, 0, 1447, 1448, 3, 1025, 512, 0, 1448, 1449, 5, 95, 0, 0, 1449, 1450, 3, 1033, 516, 0, 1450, 1451, 3, 1027, 513, 0, 1451, 1452, 5, 95, 0, 0, 1452, 1453, 3, 1043, 521, 0, 1453, 1454, 3, 1045, 522, 0, 1454, 1455, 5, 95, 0, 0, 1455, 1456, 3, 1051, 525, 0, 1456, 1457, 3, 1025, 512, 0, 1457, 1458, 3, 1027, 513, 0, 1458, 1459, 3, 1025, 512, 0, 1459, 1460, 3, 1051, 525, 0, 1460, 1461, 3, 1025, 512, 0, 1461, 1462, 3, 1043, 521, 0, 1462, 1463, 3, 1021, 510, 0, 1463, 1464, 3, 1025, 512, 0, 1464, 1465, 3, 1053, 526, 0, 1465, 1488, 1, 0, 0, 0, 1466, 1467, 3, 1023, 511, 0, 1467, 1468, 3, 1025, 512, 0, 1468, 1469, 3, 1039, 519, 0, 1469, 1470, 3, 1025, 512, 0, 1470, 1471, 3, 1055, 527, 0, 1471, 1472, 3, 1025, 512, 0, 1472, 1473, 3, 1033, 516, 0, 1473, 1474, 3, 1027, 513, 0, 1474, 1475, 3, 1043, 521, 0, 1475, 1476, 3, 1045, 522, 0, 1476, 1477, 3, 1051, 525, 0, 1477, 1478, 3, 1025, 512, 0, 1478, 1479, 3, 1027, 513, 0, 1479, 1480, 3, 1025, 512, 0, 1480, 1481, 3, 1051, 525, 0, 1481, 1482, 3, 1025, 512, 0, 1482, 1483, 3, 1043, 521, 0, 1483, 1484, 3, 1021, 510, 0, 1484, 1485, 3, 1025, 512, 0, 1485, 1486, 3, 1053, 526, 0, 1486, 1488, 1, 0, 0, 0, 1487, 1406, 1, 0, 0, 0, 1487, 1442, 1, 0, 0, 0, 1487, 1466, 1, 0, 0, 0, 1488, 32, 1, 0, 0, 0, 1489, 1490, 3, 1021, 510, 0, 1490, 1491, 3, 1051, 525, 0, 1491, 1492, 3, 1025, 512, 0, 1492, 1493, 3, 1017, 508, 0, 1493, 1494, 3, 1055, 527, 0, 1494, 1495, 3, 1025, 512, 0, 1495, 34, 1, 0, 0, 0, 1496, 1497, 3, 1017, 508, 0, 1497, 1498, 3, 1039, 519, 0, 1498, 1499, 3, 1055, 527, 0, 1499, 1500, 3, 1025, 512, 0, 1500, 1501, 3, 1051, 525, 0, 1501, 36, 1, 0, 0, 0, 1502, 1503, 3, 1023, 511, 0, 1503, 1504, 3, 1051, 525, 0, 1504, 1505, 3, 1045, 522, 0, 1505, 1506, 3, 1047, 523, 0, 1506, 38, 1, 0, 0, 0, 1507, 1508, 3, 1051, 525, 0, 1508, 1509, 3, 1025, 512, 0, 1509, 1510, 3, 1043, 521, 0, 1510, 1511, 3, 1017, 508, 0, 1511, 1512, 3, 1041, 520, 0, 1512, 1513, 3, 1025, 512, 0, 1513, 40, 1, 0, 0, 0, 1514, 1515, 3, 1041, 520, 0, 1515, 1516, 3, 1045, 522, 0, 1516, 1517, 3, 1059, 529, 0, 1517, 1518, 3, 1025, 512, 0, 1518, 42, 1, 0, 0, 0, 1519, 1520, 3, 1041, 520, 0, 1520, 1521, 3, 1045, 522, 0, 1521, 1522, 3, 1023, 511, 0, 1522, 1523, 3, 1033, 516, 0, 1523, 1524, 3, 1027, 513, 0, 1524, 1525, 3, 1065, 532, 0, 1525, 44, 1, 0, 0, 0, 1526, 1527, 3, 1025, 512, 0, 1527, 1528, 3, 1043, 521, 0, 1528, 1529, 3, 1055, 527, 0, 1529, 1530, 3, 1033, 516, 0, 1530, 1531, 3, 1055, 527, 0, 1531, 1532, 3, 1065, 532, 0, 1532, 46, 1, 0, 0, 0, 1533, 1534, 3, 1047, 523, 0, 1534, 1535, 3, 1025, 512, 0, 1535, 1536, 3, 1051, 525, 0, 1536, 1537, 3, 1053, 526, 0, 1537, 1538, 3, 1033, 516, 0, 1538, 1539, 3, 1053, 526, 0, 1539, 1540, 3, 1055, 527, 0, 1540, 1541, 3, 1025, 512, 0, 1541, 1542, 3, 1043, 521, 0, 1542, 1543, 3, 1055, 527, 0, 1543, 48, 1, 0, 0, 0, 1544, 1545, 3, 1059, 529, 0, 1545, 1546, 3, 1033, 516, 0, 1546, 1547, 3, 1025, 512, 0, 1547, 1548, 3, 1061, 530, 0, 1548, 50, 1, 0, 0, 0, 1549, 1550, 3, 1025, 512, 0, 1550, 1551, 3, 1063, 531, 0, 1551, 1552, 3, 1055, 527, 0, 1552, 1553, 3, 1025, 512, 0, 1553, 1554, 3, 1051, 525, 0, 1554, 1555, 3, 1043, 521, 0, 1555, 1556, 3, 1017, 508, 0, 1556, 1557, 3, 1039, 519, 0, 1557, 52, 1, 0, 0, 0, 1558, 1559, 3, 1017, 508, 0, 1559, 1560, 3, 1053, 526, 0, 1560, 1561, 3, 1053, 526, 0, 1561, 1562, 3, 1045, 522, 0, 1562, 1563, 3, 1021, 510, 0, 1563, 1564, 3, 1033, 516, 0, 1564, 1565, 3, 1017, 508, 0, 1565, 1566, 3, 1055, 527, 0, 1566, 1567, 3, 1033, 516, 0, 1567, 1568, 3, 1045, 522, 0, 1568, 1569, 3, 1043, 521, 0, 1569, 54, 1, 0, 0, 0, 1570, 1571, 3, 1025, 512, 0, 1571, 1572, 3, 1043, 521, 0, 1572, 1573, 3, 1057, 528, 0, 1573, 1574, 3, 1041, 520, 0, 1574, 1575, 3, 1025, 512, 0, 1575, 1576, 3, 1051, 525, 0, 1576, 1577, 3, 1017, 508, 0, 1577, 1578, 3, 1055, 527, 0, 1578, 1579, 3, 1033, 516, 0, 1579, 1580, 3, 1045, 522, 0, 1580, 1581, 3, 1043, 521, 0, 1581, 56, 1, 0, 0, 0, 1582, 1583, 3, 1041, 520, 0, 1583, 1584, 3, 1045, 522, 0, 1584, 1585, 3, 1023, 511, 0, 1585, 1586, 3, 1057, 528, 0, 1586, 1587, 3, 1039, 519, 0, 1587, 1588, 3, 1025, 512, 0, 1588, 58, 1, 0, 0, 0, 1589, 1590, 3, 1041, 520, 0, 1590, 1591, 3, 1033, 516, 0, 1591, 1592, 3, 1021, 510, 0, 1592, 1593, 3, 1051, 525, 0, 1593, 1594, 3, 1045, 522, 0, 1594, 1595, 3, 1027, 513, 0, 1595, 1596, 3, 1039, 519, 0, 1596, 1597, 3, 1045, 522, 0, 1597, 1598, 3, 1061, 530, 0, 1598, 60, 1, 0, 0, 0, 1599, 1600, 3, 1043, 521, 0, 1600, 1601, 3, 1017, 508, 0, 1601, 1602, 3, 1043, 521, 0, 1602, 1603, 3, 1045, 522, 0, 1603, 1604, 3, 1027, 513, 0, 1604, 1605, 3, 1039, 519, 0, 1605, 1606, 3, 1045, 522, 0, 1606, 1607, 3, 1061, 530, 0, 1607, 62, 1, 0, 0, 0, 1608, 1609, 3, 1061, 530, 0, 1609, 1610, 3, 1045, 522, 0, 1610, 1611, 3, 1051, 525, 0, 1611, 1612, 3, 1037, 518, 0, 1612, 1613, 3, 1027, 513, 0, 1613, 1614, 3, 1039, 519, 0, 1614, 1615, 3, 1045, 522, 0, 1615, 1616, 3, 1061, 530, 0, 1616, 64, 1, 0, 0, 0, 1617, 1618, 3, 1047, 523, 0, 1618, 1619, 3, 1017, 508, 0, 1619, 1620, 3, 1029, 514, 0, 1620, 1621, 3, 1025, 512, 0, 1621, 66, 1, 0, 0, 0, 1622, 1623, 3, 1053, 526, 0, 1623, 1624, 3, 1043, 521, 0, 1624, 1625, 3, 1033, 516, 0, 1625, 1626, 3, 1047, 523, 0, 1626, 1627, 3, 1047, 523, 0, 1627, 1628, 3, 1025, 512, 0, 1628, 1629, 3, 1055, 527, 0, 1629, 68, 1, 0, 0, 0, 1630, 1631, 3, 1039, 519, 0, 1631, 1632, 3, 1017, 508, 0, 1632, 1633, 3, 1065, 532, 0, 1633, 1634, 3, 1045, 522, 0, 1634, 1635, 3, 1057, 528, 0, 1635, 1636, 3, 1055, 527, 0, 1636, 70, 1, 0, 0, 0, 1637, 1638, 3, 1043, 521, 0, 1638, 1639, 3, 1045, 522, 0, 1639, 1640, 3, 1055, 527, 0, 1640, 1641, 3, 1025, 512, 0, 1641, 1642, 3, 1019, 509, 0, 1642, 1643, 3, 1045, 522, 0, 1643, 1644, 3, 1045, 522, 0, 1644, 1645, 3, 1037, 518, 0, 1645, 72, 1, 0, 0, 0, 1646, 1647, 3, 1021, 510, 0, 1647, 1648, 3, 1045, 522, 0, 1648, 1649, 3, 1043, 521, 0, 1649, 1650, 3, 1053, 526, 0, 1650, 1651, 3, 1055, 527, 0, 1651, 1652, 3, 1017, 508, 0, 1652, 1653, 3, 1043, 521, 0, 1653, 1654, 3, 1055, 527, 0, 1654, 74, 1, 0, 0, 0, 1655, 1656, 3, 1017, 508, 0, 1656, 1657, 3, 1055, 527, 0, 1657, 1658, 3, 1055, 527, 0, 1658, 1659, 3, 1051, 525, 0, 1659, 1660, 3, 1033, 516, 0, 1660, 1661, 3, 1019, 509, 0, 1661, 1662, 3, 1057, 528, 0, 1662, 1663, 3, 1055, 527, 0, 1663, 1664, 3, 1025, 512, 0, 1664, 76, 1, 0, 0, 0, 1665, 1666, 3, 1021, 510, 0, 1666, 1667, 3, 1045, 522, 0, 1667, 1668, 3, 1039, 519, 0, 1668, 1669, 3, 1057, 528, 0, 1669, 1670, 3, 1041, 520, 0, 1670, 1671, 3, 1043, 521, 0, 1671, 78, 1, 0, 0, 0, 1672, 1673, 3, 1021, 510, 0, 1673, 1674, 3, 1045, 522, 0, 1674, 1675, 3, 1039, 519, 0, 1675, 1676, 3, 1057, 528, 0, 1676, 1677, 3, 1041, 520, 0, 1677, 1678, 3, 1043, 521, 0, 1678, 1679, 3, 1053, 526, 0, 1679, 80, 1, 0, 0, 0, 1680, 1681, 3, 1033, 516, 0, 1681, 1682, 3, 1043, 521, 0, 1682, 1683, 3, 1023, 511, 0, 1683, 1684, 3, 1025, 512, 0, 1684, 1685, 3, 1063, 531, 0, 1685, 82, 1, 0, 0, 0, 1686, 1687, 3, 1045, 522, 0, 1687, 1688, 3, 1061, 530, 0, 1688, 1689, 3, 1043, 521, 0, 1689, 1690, 3, 1025, 512, 0, 1690, 1691, 3, 1051, 525, 0, 1691, 84, 1, 0, 0, 0, 1692, 1693, 3, 1051, 525, 0, 1693, 1694, 3, 1025, 512, 0, 1694, 1695, 3, 1027, 513, 0, 1695, 1696, 3, 1025, 512, 0, 1696, 1697, 3, 1051, 525, 0, 1697, 1698, 3, 1025, 512, 0, 1698, 1699, 3, 1043, 521, 0, 1699, 1700, 3, 1021, 510, 0, 1700, 1701, 3, 1025, 512, 0, 1701, 86, 1, 0, 0, 0, 1702, 1703, 3, 1029, 514, 0, 1703, 1704, 3, 1025, 512, 0, 1704, 1705, 3, 1043, 521, 0, 1705, 1706, 3, 1025, 512, 0, 1706, 1707, 3, 1051, 525, 0, 1707, 1708, 3, 1017, 508, 0, 1708, 1709, 3, 1039, 519, 0, 1709, 1710, 3, 1033, 516, 0, 1710, 1711, 3, 1067, 533, 0, 1711, 1712, 3, 1017, 508, 0, 1712, 1713, 3, 1055, 527, 0, 1713, 1714, 3, 1033, 516, 0, 1714, 1715, 3, 1045, 522, 0, 1715, 1716, 3, 1043, 521, 0, 1716, 88, 1, 0, 0, 0, 1717, 1718, 3, 1025, 512, 0, 1718, 1719, 3, 1063, 531, 0, 1719, 1720, 3, 1055, 527, 0, 1720, 1721, 3, 1025, 512, 0, 1721, 1722, 3, 1043, 521, 0, 1722, 1723, 3, 1023, 511, 0, 1723, 1724, 3, 1053, 526, 0, 1724, 90, 1, 0, 0, 0, 1725, 1726, 3, 1017, 508, 0, 1726, 1727, 3, 1023, 511, 0, 1727, 1728, 3, 1023, 511, 0, 1728, 92, 1, 0, 0, 0, 1729, 1730, 3, 1053, 526, 0, 1730, 1731, 3, 1025, 512, 0, 1731, 1732, 3, 1055, 527, 0, 1732, 94, 1, 0, 0, 0, 1733, 1734, 3, 1047, 523, 0, 1734, 1735, 3, 1045, 522, 0, 1735, 1736, 3, 1053, 526, 0, 1736, 1737, 3, 1033, 516, 0, 1737, 1738, 3, 1055, 527, 0, 1738, 1739, 3, 1033, 516, 0, 1739, 1740, 3, 1045, 522, 0, 1740, 1741, 3, 1043, 521, 0, 1741, 96, 1, 0, 0, 0, 1742, 1743, 3, 1023, 511, 0, 1743, 1744, 3, 1045, 522, 0, 1744, 1745, 3, 1021, 510, 0, 1745, 1746, 3, 1057, 528, 0, 1746, 1747, 3, 1041, 520, 0, 1747, 1748, 3, 1025, 512, 0, 1748, 1749, 3, 1043, 521, 0, 1749, 1750, 3, 1055, 527, 0, 1750, 1751, 3, 1017, 508, 0, 1751, 1752, 3, 1055, 527, 0, 1752, 1753, 3, 1033, 516, 0, 1753, 1754, 3, 1045, 522, 0, 1754, 1755, 3, 1043, 521, 0, 1755, 98, 1, 0, 0, 0, 1756, 1757, 3, 1053, 526, 0, 1757, 1758, 3, 1055, 527, 0, 1758, 1759, 3, 1045, 522, 0, 1759, 1760, 3, 1051, 525, 0, 1760, 1761, 3, 1017, 508, 0, 1761, 1762, 3, 1029, 514, 0, 1762, 1763, 3, 1025, 512, 0, 1763, 100, 1, 0, 0, 0, 1764, 1765, 3, 1055, 527, 0, 1765, 1766, 3, 1017, 508, 0, 1766, 1767, 3, 1019, 509, 0, 1767, 1768, 3, 1039, 519, 0, 1768, 1769, 3, 1025, 512, 0, 1769, 102, 1, 0, 0, 0, 1770, 1771, 3, 1023, 511, 0, 1771, 1772, 3, 1025, 512, 0, 1772, 1773, 3, 1039, 519, 0, 1773, 1774, 3, 1025, 512, 0, 1774, 1775, 3, 1055, 527, 0, 1775, 1777, 3, 1025, 512, 0, 1776, 1778, 5, 95, 0, 0, 1777, 1776, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1780, 3, 1019, 509, 0, 1780, 1781, 3, 1025, 512, 0, 1781, 1782, 3, 1031, 515, 0, 1782, 1783, 3, 1017, 508, 0, 1783, 1784, 3, 1059, 529, 0, 1784, 1785, 3, 1033, 516, 0, 1785, 1786, 3, 1045, 522, 0, 1786, 1787, 3, 1051, 525, 0, 1787, 104, 1, 0, 0, 0, 1788, 1789, 3, 1021, 510, 0, 1789, 1790, 3, 1017, 508, 0, 1790, 1791, 3, 1053, 526, 0, 1791, 1792, 3, 1021, 510, 0, 1792, 1793, 3, 1017, 508, 0, 1793, 1794, 3, 1023, 511, 0, 1794, 1795, 3, 1025, 512, 0, 1795, 106, 1, 0, 0, 0, 1796, 1797, 3, 1047, 523, 0, 1797, 1798, 3, 1051, 525, 0, 1798, 1799, 3, 1025, 512, 0, 1799, 1800, 3, 1059, 529, 0, 1800, 1801, 3, 1025, 512, 0, 1801, 1802, 3, 1043, 521, 0, 1802, 1803, 3, 1055, 527, 0, 1803, 108, 1, 0, 0, 0, 1804, 1805, 3, 1021, 510, 0, 1805, 1806, 3, 1045, 522, 0, 1806, 1807, 3, 1043, 521, 0, 1807, 1808, 3, 1043, 521, 0, 1808, 1809, 3, 1025, 512, 0, 1809, 1810, 3, 1021, 510, 0, 1810, 1811, 3, 1055, 527, 0, 1811, 110, 1, 0, 0, 0, 1812, 1813, 3, 1023, 511, 0, 1813, 1814, 3, 1033, 516, 0, 1814, 1815, 3, 1053, 526, 0, 1815, 1816, 3, 1021, 510, 0, 1816, 1817, 3, 1045, 522, 0, 1817, 1818, 3, 1043, 521, 0, 1818, 1819, 3, 1043, 521, 0, 1819, 1820, 3, 1025, 512, 0, 1820, 1821, 3, 1021, 510, 0, 1821, 1822, 3, 1055, 527, 0, 1822, 112, 1, 0, 0, 0, 1823, 1824, 3, 1039, 519, 0, 1824, 1825, 3, 1045, 522, 0, 1825, 1826, 3, 1021, 510, 0, 1826, 1827, 3, 1017, 508, 0, 1827, 1828, 3, 1039, 519, 0, 1828, 114, 1, 0, 0, 0, 1829, 1830, 3, 1047, 523, 0, 1830, 1831, 3, 1051, 525, 0, 1831, 1832, 3, 1045, 522, 0, 1832, 1833, 3, 1035, 517, 0, 1833, 1834, 3, 1025, 512, 0, 1834, 1835, 3, 1021, 510, 0, 1835, 1836, 3, 1055, 527, 0, 1836, 116, 1, 0, 0, 0, 1837, 1838, 3, 1051, 525, 0, 1838, 1839, 3, 1057, 528, 0, 1839, 1840, 3, 1043, 521, 0, 1840, 1841, 3, 1055, 527, 0, 1841, 1842, 3, 1033, 516, 0, 1842, 1843, 3, 1041, 520, 0, 1843, 1844, 3, 1025, 512, 0, 1844, 118, 1, 0, 0, 0, 1845, 1846, 3, 1019, 509, 0, 1846, 1847, 3, 1051, 525, 0, 1847, 1848, 3, 1017, 508, 0, 1848, 1849, 3, 1043, 521, 0, 1849, 1850, 3, 1021, 510, 0, 1850, 1851, 3, 1031, 515, 0, 1851, 120, 1, 0, 0, 0, 1852, 1853, 3, 1055, 527, 0, 1853, 1854, 3, 1045, 522, 0, 1854, 1855, 3, 1037, 518, 0, 1855, 1856, 3, 1025, 512, 0, 1856, 1857, 3, 1043, 521, 0, 1857, 122, 1, 0, 0, 0, 1858, 1859, 3, 1031, 515, 0, 1859, 1860, 3, 1045, 522, 0, 1860, 1861, 3, 1053, 526, 0, 1861, 1862, 3, 1055, 527, 0, 1862, 124, 1, 0, 0, 0, 1863, 1864, 3, 1047, 523, 0, 1864, 1865, 3, 1045, 522, 0, 1865, 1866, 3, 1051, 525, 0, 1866, 1867, 3, 1055, 527, 0, 1867, 126, 1, 0, 0, 0, 1868, 1869, 3, 1053, 526, 0, 1869, 1870, 3, 1031, 515, 0, 1870, 1871, 3, 1045, 522, 0, 1871, 1872, 3, 1061, 530, 0, 1872, 128, 1, 0, 0, 0, 1873, 1874, 3, 1023, 511, 0, 1874, 1875, 3, 1025, 512, 0, 1875, 1876, 3, 1053, 526, 0, 1876, 1877, 3, 1021, 510, 0, 1877, 1878, 3, 1051, 525, 0, 1878, 1879, 3, 1033, 516, 0, 1879, 1880, 3, 1019, 509, 0, 1880, 1881, 3, 1025, 512, 0, 1881, 130, 1, 0, 0, 0, 1882, 1883, 3, 1057, 528, 0, 1883, 1884, 3, 1053, 526, 0, 1884, 1885, 3, 1025, 512, 0, 1885, 132, 1, 0, 0, 0, 1886, 1887, 3, 1033, 516, 0, 1887, 1888, 3, 1043, 521, 0, 1888, 1889, 3, 1055, 527, 0, 1889, 1890, 3, 1051, 525, 0, 1890, 1891, 3, 1045, 522, 0, 1891, 1892, 3, 1053, 526, 0, 1892, 1893, 3, 1047, 523, 0, 1893, 1894, 3, 1025, 512, 0, 1894, 1895, 3, 1021, 510, 0, 1895, 1896, 3, 1055, 527, 0, 1896, 134, 1, 0, 0, 0, 1897, 1898, 3, 1023, 511, 0, 1898, 1899, 3, 1025, 512, 0, 1899, 1900, 3, 1019, 509, 0, 1900, 1901, 3, 1057, 528, 0, 1901, 1902, 3, 1029, 514, 0, 1902, 136, 1, 0, 0, 0, 1903, 1904, 3, 1053, 526, 0, 1904, 1905, 3, 1025, 512, 0, 1905, 1906, 3, 1039, 519, 0, 1906, 1907, 3, 1025, 512, 0, 1907, 1908, 3, 1021, 510, 0, 1908, 1909, 3, 1055, 527, 0, 1909, 138, 1, 0, 0, 0, 1910, 1911, 3, 1027, 513, 0, 1911, 1912, 3, 1051, 525, 0, 1912, 1913, 3, 1045, 522, 0, 1913, 1914, 3, 1041, 520, 0, 1914, 140, 1, 0, 0, 0, 1915, 1916, 3, 1061, 530, 0, 1916, 1917, 3, 1031, 515, 0, 1917, 1918, 3, 1025, 512, 0, 1918, 1919, 3, 1051, 525, 0, 1919, 1920, 3, 1025, 512, 0, 1920, 142, 1, 0, 0, 0, 1921, 1922, 3, 1031, 515, 0, 1922, 1923, 3, 1017, 508, 0, 1923, 1924, 3, 1059, 529, 0, 1924, 1925, 3, 1033, 516, 0, 1925, 1926, 3, 1043, 521, 0, 1926, 1927, 3, 1029, 514, 0, 1927, 144, 1, 0, 0, 0, 1928, 1929, 3, 1045, 522, 0, 1929, 1930, 3, 1027, 513, 0, 1930, 1931, 3, 1027, 513, 0, 1931, 1932, 3, 1053, 526, 0, 1932, 1933, 3, 1025, 512, 0, 1933, 1934, 3, 1055, 527, 0, 1934, 146, 1, 0, 0, 0, 1935, 1936, 3, 1039, 519, 0, 1936, 1937, 3, 1033, 516, 0, 1937, 1938, 3, 1041, 520, 0, 1938, 1939, 3, 1033, 516, 0, 1939, 1940, 3, 1055, 527, 0, 1940, 148, 1, 0, 0, 0, 1941, 1942, 3, 1017, 508, 0, 1942, 1943, 3, 1053, 526, 0, 1943, 150, 1, 0, 0, 0, 1944, 1945, 3, 1051, 525, 0, 1945, 1946, 3, 1025, 512, 0, 1946, 1947, 3, 1055, 527, 0, 1947, 1948, 3, 1057, 528, 0, 1948, 1949, 3, 1051, 525, 0, 1949, 1950, 3, 1043, 521, 0, 1950, 1951, 3, 1053, 526, 0, 1951, 152, 1, 0, 0, 0, 1952, 1953, 3, 1051, 525, 0, 1953, 1954, 3, 1025, 512, 0, 1954, 1955, 3, 1055, 527, 0, 1955, 1956, 3, 1057, 528, 0, 1956, 1957, 3, 1051, 525, 0, 1957, 1958, 3, 1043, 521, 0, 1958, 1959, 3, 1033, 516, 0, 1959, 1960, 3, 1043, 521, 0, 1960, 1961, 3, 1029, 514, 0, 1961, 154, 1, 0, 0, 0, 1962, 1963, 3, 1021, 510, 0, 1963, 1964, 3, 1017, 508, 0, 1964, 1965, 3, 1053, 526, 0, 1965, 1966, 3, 1025, 512, 0, 1966, 156, 1, 0, 0, 0, 1967, 1968, 3, 1061, 530, 0, 1968, 1969, 3, 1031, 515, 0, 1969, 1970, 3, 1025, 512, 0, 1970, 1971, 3, 1043, 521, 0, 1971, 158, 1, 0, 0, 0, 1972, 1973, 3, 1055, 527, 0, 1973, 1974, 3, 1031, 515, 0, 1974, 1975, 3, 1025, 512, 0, 1975, 1976, 3, 1043, 521, 0, 1976, 160, 1, 0, 0, 0, 1977, 1978, 3, 1025, 512, 0, 1978, 1979, 3, 1039, 519, 0, 1979, 1980, 3, 1053, 526, 0, 1980, 1981, 3, 1025, 512, 0, 1981, 162, 1, 0, 0, 0, 1982, 1983, 3, 1025, 512, 0, 1983, 1984, 3, 1043, 521, 0, 1984, 1985, 3, 1023, 511, 0, 1985, 164, 1, 0, 0, 0, 1986, 1987, 3, 1023, 511, 0, 1987, 1988, 3, 1033, 516, 0, 1988, 1989, 3, 1053, 526, 0, 1989, 1990, 3, 1055, 527, 0, 1990, 1991, 3, 1033, 516, 0, 1991, 1992, 3, 1043, 521, 0, 1992, 1993, 3, 1021, 510, 0, 1993, 1994, 3, 1055, 527, 0, 1994, 166, 1, 0, 0, 0, 1995, 1996, 3, 1017, 508, 0, 1996, 1997, 3, 1039, 519, 0, 1997, 1998, 3, 1039, 519, 0, 1998, 168, 1, 0, 0, 0, 1999, 2000, 3, 1035, 517, 0, 2000, 2001, 3, 1045, 522, 0, 2001, 2002, 3, 1033, 516, 0, 2002, 2003, 3, 1043, 521, 0, 2003, 170, 1, 0, 0, 0, 2004, 2005, 3, 1039, 519, 0, 2005, 2006, 3, 1025, 512, 0, 2006, 2007, 3, 1027, 513, 0, 2007, 2008, 3, 1055, 527, 0, 2008, 172, 1, 0, 0, 0, 2009, 2010, 3, 1051, 525, 0, 2010, 2011, 3, 1033, 516, 0, 2011, 2012, 3, 1029, 514, 0, 2012, 2013, 3, 1031, 515, 0, 2013, 2014, 3, 1055, 527, 0, 2014, 174, 1, 0, 0, 0, 2015, 2016, 3, 1033, 516, 0, 2016, 2017, 3, 1043, 521, 0, 2017, 2018, 3, 1043, 521, 0, 2018, 2019, 3, 1025, 512, 0, 2019, 2020, 3, 1051, 525, 0, 2020, 176, 1, 0, 0, 0, 2021, 2022, 3, 1045, 522, 0, 2022, 2023, 3, 1057, 528, 0, 2023, 2024, 3, 1055, 527, 0, 2024, 2025, 3, 1025, 512, 0, 2025, 2026, 3, 1051, 525, 0, 2026, 178, 1, 0, 0, 0, 2027, 2028, 3, 1027, 513, 0, 2028, 2029, 3, 1057, 528, 0, 2029, 2030, 3, 1039, 519, 0, 2030, 2031, 3, 1039, 519, 0, 2031, 180, 1, 0, 0, 0, 2032, 2033, 3, 1021, 510, 0, 2033, 2034, 3, 1051, 525, 0, 2034, 2035, 3, 1045, 522, 0, 2035, 2036, 3, 1053, 526, 0, 2036, 2037, 3, 1053, 526, 0, 2037, 182, 1, 0, 0, 0, 2038, 2039, 3, 1045, 522, 0, 2039, 2040, 3, 1043, 521, 0, 2040, 184, 1, 0, 0, 0, 2041, 2042, 3, 1017, 508, 0, 2042, 2043, 3, 1053, 526, 0, 2043, 2044, 3, 1021, 510, 0, 2044, 186, 1, 0, 0, 0, 2045, 2046, 3, 1023, 511, 0, 2046, 2047, 3, 1025, 512, 0, 2047, 2048, 3, 1053, 526, 0, 2048, 2049, 3, 1021, 510, 0, 2049, 188, 1, 0, 0, 0, 2050, 2051, 3, 1019, 509, 0, 2051, 2052, 3, 1025, 512, 0, 2052, 2053, 3, 1029, 514, 0, 2053, 2054, 3, 1033, 516, 0, 2054, 2055, 3, 1043, 521, 0, 2055, 190, 1, 0, 0, 0, 2056, 2057, 3, 1023, 511, 0, 2057, 2058, 3, 1025, 512, 0, 2058, 2059, 3, 1021, 510, 0, 2059, 2060, 3, 1039, 519, 0, 2060, 2061, 3, 1017, 508, 0, 2061, 2062, 3, 1051, 525, 0, 2062, 2063, 3, 1025, 512, 0, 2063, 192, 1, 0, 0, 0, 2064, 2065, 3, 1021, 510, 0, 2065, 2066, 3, 1031, 515, 0, 2066, 2067, 3, 1017, 508, 0, 2067, 2068, 3, 1043, 521, 0, 2068, 2069, 3, 1029, 514, 0, 2069, 2070, 3, 1025, 512, 0, 2070, 194, 1, 0, 0, 0, 2071, 2072, 3, 1051, 525, 0, 2072, 2073, 3, 1025, 512, 0, 2073, 2074, 3, 1055, 527, 0, 2074, 2075, 3, 1051, 525, 0, 2075, 2076, 3, 1033, 516, 0, 2076, 2077, 3, 1025, 512, 0, 2077, 2078, 3, 1059, 529, 0, 2078, 2079, 3, 1025, 512, 0, 2079, 196, 1, 0, 0, 0, 2080, 2081, 3, 1023, 511, 0, 2081, 2082, 3, 1025, 512, 0, 2082, 2083, 3, 1039, 519, 0, 2083, 2084, 3, 1025, 512, 0, 2084, 2085, 3, 1055, 527, 0, 2085, 2086, 3, 1025, 512, 0, 2086, 198, 1, 0, 0, 0, 2087, 2088, 3, 1021, 510, 0, 2088, 2089, 3, 1045, 522, 0, 2089, 2090, 3, 1041, 520, 0, 2090, 2091, 3, 1041, 520, 0, 2091, 2092, 3, 1033, 516, 0, 2092, 2093, 3, 1055, 527, 0, 2093, 200, 1, 0, 0, 0, 2094, 2095, 3, 1051, 525, 0, 2095, 2096, 3, 1045, 522, 0, 2096, 2097, 3, 1039, 519, 0, 2097, 2098, 3, 1039, 519, 0, 2098, 2099, 3, 1019, 509, 0, 2099, 2100, 3, 1017, 508, 0, 2100, 2101, 3, 1021, 510, 0, 2101, 2102, 3, 1037, 518, 0, 2102, 202, 1, 0, 0, 0, 2103, 2104, 3, 1039, 519, 0, 2104, 2105, 3, 1045, 522, 0, 2105, 2106, 3, 1045, 522, 0, 2106, 2107, 3, 1047, 523, 0, 2107, 204, 1, 0, 0, 0, 2108, 2109, 3, 1061, 530, 0, 2109, 2110, 3, 1031, 515, 0, 2110, 2111, 3, 1033, 516, 0, 2111, 2112, 3, 1039, 519, 0, 2112, 2113, 3, 1025, 512, 0, 2113, 206, 1, 0, 0, 0, 2114, 2115, 3, 1033, 516, 0, 2115, 2116, 3, 1027, 513, 0, 2116, 208, 1, 0, 0, 0, 2117, 2118, 3, 1025, 512, 0, 2118, 2119, 3, 1039, 519, 0, 2119, 2120, 3, 1053, 526, 0, 2120, 2121, 3, 1033, 516, 0, 2121, 2122, 3, 1027, 513, 0, 2122, 210, 1, 0, 0, 0, 2123, 2124, 3, 1025, 512, 0, 2124, 2125, 3, 1039, 519, 0, 2125, 2126, 3, 1053, 526, 0, 2126, 2127, 3, 1025, 512, 0, 2127, 2128, 3, 1033, 516, 0, 2128, 2129, 3, 1027, 513, 0, 2129, 212, 1, 0, 0, 0, 2130, 2131, 3, 1021, 510, 0, 2131, 2132, 3, 1045, 522, 0, 2132, 2133, 3, 1043, 521, 0, 2133, 2134, 3, 1055, 527, 0, 2134, 2135, 3, 1033, 516, 0, 2135, 2136, 3, 1043, 521, 0, 2136, 2137, 3, 1057, 528, 0, 2137, 2138, 3, 1025, 512, 0, 2138, 214, 1, 0, 0, 0, 2139, 2140, 3, 1019, 509, 0, 2140, 2141, 3, 1051, 525, 0, 2141, 2142, 3, 1025, 512, 0, 2142, 2143, 3, 1017, 508, 0, 2143, 2144, 3, 1037, 518, 0, 2144, 216, 1, 0, 0, 0, 2145, 2146, 3, 1051, 525, 0, 2146, 2147, 3, 1025, 512, 0, 2147, 2148, 3, 1055, 527, 0, 2148, 2149, 3, 1057, 528, 0, 2149, 2150, 3, 1051, 525, 0, 2150, 2151, 3, 1043, 521, 0, 2151, 218, 1, 0, 0, 0, 2152, 2153, 3, 1055, 527, 0, 2153, 2154, 3, 1031, 515, 0, 2154, 2155, 3, 1051, 525, 0, 2155, 2156, 3, 1045, 522, 0, 2156, 2157, 3, 1061, 530, 0, 2157, 220, 1, 0, 0, 0, 2158, 2159, 3, 1039, 519, 0, 2159, 2160, 3, 1045, 522, 0, 2160, 2161, 3, 1029, 514, 0, 2161, 222, 1, 0, 0, 0, 2162, 2163, 3, 1021, 510, 0, 2163, 2164, 3, 1017, 508, 0, 2164, 2165, 3, 1039, 519, 0, 2165, 2166, 3, 1039, 519, 0, 2166, 224, 1, 0, 0, 0, 2167, 2168, 3, 1035, 517, 0, 2168, 2169, 3, 1017, 508, 0, 2169, 2170, 3, 1059, 529, 0, 2170, 2171, 3, 1017, 508, 0, 2171, 226, 1, 0, 0, 0, 2172, 2173, 3, 1017, 508, 0, 2173, 2174, 3, 1021, 510, 0, 2174, 2175, 3, 1055, 527, 0, 2175, 2176, 3, 1033, 516, 0, 2176, 2177, 3, 1045, 522, 0, 2177, 2178, 3, 1043, 521, 0, 2178, 228, 1, 0, 0, 0, 2179, 2180, 3, 1017, 508, 0, 2180, 2181, 3, 1021, 510, 0, 2181, 2182, 3, 1055, 527, 0, 2182, 2183, 3, 1033, 516, 0, 2183, 2184, 3, 1045, 522, 0, 2184, 2185, 3, 1043, 521, 0, 2185, 2186, 3, 1053, 526, 0, 2186, 230, 1, 0, 0, 0, 2187, 2188, 3, 1021, 510, 0, 2188, 2189, 3, 1039, 519, 0, 2189, 2190, 3, 1045, 522, 0, 2190, 2191, 3, 1053, 526, 0, 2191, 2192, 3, 1025, 512, 0, 2192, 232, 1, 0, 0, 0, 2193, 2194, 3, 1043, 521, 0, 2194, 2195, 3, 1045, 522, 0, 2195, 2196, 3, 1023, 511, 0, 2196, 2197, 3, 1025, 512, 0, 2197, 234, 1, 0, 0, 0, 2198, 2199, 3, 1025, 512, 0, 2199, 2200, 3, 1059, 529, 0, 2200, 2201, 3, 1025, 512, 0, 2201, 2202, 3, 1043, 521, 0, 2202, 2203, 3, 1055, 527, 0, 2203, 2204, 3, 1053, 526, 0, 2204, 236, 1, 0, 0, 0, 2205, 2206, 3, 1031, 515, 0, 2206, 2207, 3, 1025, 512, 0, 2207, 2208, 3, 1017, 508, 0, 2208, 2209, 3, 1023, 511, 0, 2209, 238, 1, 0, 0, 0, 2210, 2211, 3, 1055, 527, 0, 2211, 2212, 3, 1017, 508, 0, 2212, 2213, 3, 1033, 516, 0, 2213, 2214, 3, 1039, 519, 0, 2214, 240, 1, 0, 0, 0, 2215, 2216, 3, 1027, 513, 0, 2216, 2217, 3, 1033, 516, 0, 2217, 2218, 3, 1043, 521, 0, 2218, 2219, 3, 1023, 511, 0, 2219, 242, 1, 0, 0, 0, 2220, 2221, 3, 1053, 526, 0, 2221, 2222, 3, 1045, 522, 0, 2222, 2223, 3, 1051, 525, 0, 2223, 2224, 3, 1055, 527, 0, 2224, 244, 1, 0, 0, 0, 2225, 2226, 3, 1057, 528, 0, 2226, 2227, 3, 1043, 521, 0, 2227, 2228, 3, 1033, 516, 0, 2228, 2229, 3, 1045, 522, 0, 2229, 2230, 3, 1043, 521, 0, 2230, 246, 1, 0, 0, 0, 2231, 2232, 3, 1033, 516, 0, 2232, 2233, 3, 1043, 521, 0, 2233, 2234, 3, 1055, 527, 0, 2234, 2235, 3, 1025, 512, 0, 2235, 2236, 3, 1051, 525, 0, 2236, 2237, 3, 1053, 526, 0, 2237, 2238, 3, 1025, 512, 0, 2238, 2239, 3, 1021, 510, 0, 2239, 2240, 3, 1055, 527, 0, 2240, 248, 1, 0, 0, 0, 2241, 2242, 3, 1053, 526, 0, 2242, 2243, 3, 1057, 528, 0, 2243, 2244, 3, 1019, 509, 0, 2244, 2245, 3, 1055, 527, 0, 2245, 2246, 3, 1051, 525, 0, 2246, 2247, 3, 1017, 508, 0, 2247, 2248, 3, 1021, 510, 0, 2248, 2249, 3, 1055, 527, 0, 2249, 250, 1, 0, 0, 0, 2250, 2251, 3, 1021, 510, 0, 2251, 2252, 3, 1045, 522, 0, 2252, 2253, 3, 1043, 521, 0, 2253, 2254, 3, 1055, 527, 0, 2254, 2255, 3, 1017, 508, 0, 2255, 2256, 3, 1033, 516, 0, 2256, 2257, 3, 1043, 521, 0, 2257, 2258, 3, 1053, 526, 0, 2258, 252, 1, 0, 0, 0, 2259, 2260, 3, 1017, 508, 0, 2260, 2261, 3, 1059, 529, 0, 2261, 2262, 3, 1025, 512, 0, 2262, 2263, 3, 1051, 525, 0, 2263, 2264, 3, 1017, 508, 0, 2264, 2265, 3, 1029, 514, 0, 2265, 2266, 3, 1025, 512, 0, 2266, 254, 1, 0, 0, 0, 2267, 2268, 3, 1041, 520, 0, 2268, 2269, 3, 1033, 516, 0, 2269, 2270, 3, 1043, 521, 0, 2270, 2271, 3, 1033, 516, 0, 2271, 2272, 3, 1041, 520, 0, 2272, 2273, 3, 1057, 528, 0, 2273, 2274, 3, 1041, 520, 0, 2274, 256, 1, 0, 0, 0, 2275, 2276, 3, 1041, 520, 0, 2276, 2277, 3, 1017, 508, 0, 2277, 2278, 3, 1063, 531, 0, 2278, 2279, 3, 1033, 516, 0, 2279, 2280, 3, 1041, 520, 0, 2280, 2281, 3, 1057, 528, 0, 2281, 2282, 3, 1041, 520, 0, 2282, 258, 1, 0, 0, 0, 2283, 2284, 3, 1039, 519, 0, 2284, 2285, 3, 1033, 516, 0, 2285, 2286, 3, 1053, 526, 0, 2286, 2287, 3, 1055, 527, 0, 2287, 260, 1, 0, 0, 0, 2288, 2289, 3, 1051, 525, 0, 2289, 2290, 3, 1025, 512, 0, 2290, 2291, 3, 1041, 520, 0, 2291, 2292, 3, 1045, 522, 0, 2292, 2293, 3, 1059, 529, 0, 2293, 2294, 3, 1025, 512, 0, 2294, 262, 1, 0, 0, 0, 2295, 2296, 3, 1025, 512, 0, 2296, 2297, 3, 1049, 524, 0, 2297, 2298, 3, 1057, 528, 0, 2298, 2299, 3, 1017, 508, 0, 2299, 2300, 3, 1039, 519, 0, 2300, 2301, 3, 1053, 526, 0, 2301, 264, 1, 0, 0, 0, 2302, 2303, 3, 1033, 516, 0, 2303, 2304, 3, 1043, 521, 0, 2304, 2305, 3, 1027, 513, 0, 2305, 2306, 3, 1045, 522, 0, 2306, 266, 1, 0, 0, 0, 2307, 2308, 3, 1061, 530, 0, 2308, 2309, 3, 1017, 508, 0, 2309, 2310, 3, 1051, 525, 0, 2310, 2311, 3, 1043, 521, 0, 2311, 2312, 3, 1033, 516, 0, 2312, 2313, 3, 1043, 521, 0, 2313, 2314, 3, 1029, 514, 0, 2314, 268, 1, 0, 0, 0, 2315, 2316, 3, 1055, 527, 0, 2316, 2317, 3, 1051, 525, 0, 2317, 2318, 3, 1017, 508, 0, 2318, 2319, 3, 1021, 510, 0, 2319, 2320, 3, 1025, 512, 0, 2320, 270, 1, 0, 0, 0, 2321, 2322, 3, 1021, 510, 0, 2322, 2323, 3, 1051, 525, 0, 2323, 2324, 3, 1033, 516, 0, 2324, 2325, 3, 1055, 527, 0, 2325, 2326, 3, 1033, 516, 0, 2326, 2327, 3, 1021, 510, 0, 2327, 2328, 3, 1017, 508, 0, 2328, 2329, 3, 1039, 519, 0, 2329, 272, 1, 0, 0, 0, 2330, 2331, 3, 1061, 530, 0, 2331, 2332, 3, 1033, 516, 0, 2332, 2333, 3, 1055, 527, 0, 2333, 2334, 3, 1031, 515, 0, 2334, 274, 1, 0, 0, 0, 2335, 2336, 3, 1025, 512, 0, 2336, 2337, 3, 1041, 520, 0, 2337, 2338, 3, 1047, 523, 0, 2338, 2339, 3, 1055, 527, 0, 2339, 2340, 3, 1065, 532, 0, 2340, 276, 1, 0, 0, 0, 2341, 2342, 3, 1045, 522, 0, 2342, 2343, 3, 1019, 509, 0, 2343, 2344, 3, 1035, 517, 0, 2344, 2345, 3, 1025, 512, 0, 2345, 2346, 3, 1021, 510, 0, 2346, 2347, 3, 1055, 527, 0, 2347, 278, 1, 0, 0, 0, 2348, 2349, 3, 1045, 522, 0, 2349, 2350, 3, 1019, 509, 0, 2350, 2351, 3, 1035, 517, 0, 2351, 2352, 3, 1025, 512, 0, 2352, 2353, 3, 1021, 510, 0, 2353, 2354, 3, 1055, 527, 0, 2354, 2355, 3, 1053, 526, 0, 2355, 280, 1, 0, 0, 0, 2356, 2357, 3, 1047, 523, 0, 2357, 2358, 3, 1017, 508, 0, 2358, 2359, 3, 1029, 514, 0, 2359, 2360, 3, 1025, 512, 0, 2360, 2361, 3, 1053, 526, 0, 2361, 282, 1, 0, 0, 0, 2362, 2363, 3, 1039, 519, 0, 2363, 2364, 3, 1017, 508, 0, 2364, 2365, 3, 1065, 532, 0, 2365, 2366, 3, 1045, 522, 0, 2366, 2367, 3, 1057, 528, 0, 2367, 2368, 3, 1055, 527, 0, 2368, 2369, 3, 1053, 526, 0, 2369, 284, 1, 0, 0, 0, 2370, 2371, 3, 1053, 526, 0, 2371, 2372, 3, 1043, 521, 0, 2372, 2373, 3, 1033, 516, 0, 2373, 2374, 3, 1047, 523, 0, 2374, 2375, 3, 1047, 523, 0, 2375, 2376, 3, 1025, 512, 0, 2376, 2377, 3, 1055, 527, 0, 2377, 2378, 3, 1053, 526, 0, 2378, 286, 1, 0, 0, 0, 2379, 2380, 3, 1043, 521, 0, 2380, 2381, 3, 1045, 522, 0, 2381, 2382, 3, 1055, 527, 0, 2382, 2383, 3, 1025, 512, 0, 2383, 2384, 3, 1019, 509, 0, 2384, 2385, 3, 1045, 522, 0, 2385, 2386, 3, 1045, 522, 0, 2386, 2387, 3, 1037, 518, 0, 2387, 2388, 3, 1053, 526, 0, 2388, 288, 1, 0, 0, 0, 2389, 2390, 3, 1047, 523, 0, 2390, 2391, 3, 1039, 519, 0, 2391, 2392, 3, 1017, 508, 0, 2392, 2393, 3, 1021, 510, 0, 2393, 2394, 3, 1025, 512, 0, 2394, 2395, 3, 1031, 515, 0, 2395, 2396, 3, 1045, 522, 0, 2396, 2397, 3, 1039, 519, 0, 2397, 2398, 3, 1023, 511, 0, 2398, 2399, 3, 1025, 512, 0, 2399, 2400, 3, 1051, 525, 0, 2400, 290, 1, 0, 0, 0, 2401, 2402, 3, 1053, 526, 0, 2402, 2403, 3, 1043, 521, 0, 2403, 2404, 3, 1033, 516, 0, 2404, 2405, 3, 1047, 523, 0, 2405, 2406, 3, 1047, 523, 0, 2406, 2407, 3, 1025, 512, 0, 2407, 2408, 3, 1055, 527, 0, 2408, 2409, 3, 1021, 510, 0, 2409, 2410, 3, 1017, 508, 0, 2410, 2411, 3, 1039, 519, 0, 2411, 2412, 3, 1039, 519, 0, 2412, 292, 1, 0, 0, 0, 2413, 2414, 3, 1039, 519, 0, 2414, 2415, 3, 1017, 508, 0, 2415, 2416, 3, 1065, 532, 0, 2416, 2417, 3, 1045, 522, 0, 2417, 2418, 3, 1057, 528, 0, 2418, 2419, 3, 1055, 527, 0, 2419, 2420, 3, 1029, 514, 0, 2420, 2421, 3, 1051, 525, 0, 2421, 2422, 3, 1033, 516, 0, 2422, 2423, 3, 1023, 511, 0, 2423, 294, 1, 0, 0, 0, 2424, 2425, 3, 1023, 511, 0, 2425, 2426, 3, 1017, 508, 0, 2426, 2427, 3, 1055, 527, 0, 2427, 2428, 3, 1017, 508, 0, 2428, 2429, 3, 1029, 514, 0, 2429, 2430, 3, 1051, 525, 0, 2430, 2431, 3, 1033, 516, 0, 2431, 2432, 3, 1023, 511, 0, 2432, 296, 1, 0, 0, 0, 2433, 2434, 3, 1023, 511, 0, 2434, 2435, 3, 1017, 508, 0, 2435, 2436, 3, 1055, 527, 0, 2436, 2437, 3, 1017, 508, 0, 2437, 2438, 3, 1059, 529, 0, 2438, 2439, 3, 1033, 516, 0, 2439, 2440, 3, 1025, 512, 0, 2440, 2441, 3, 1061, 530, 0, 2441, 298, 1, 0, 0, 0, 2442, 2443, 3, 1039, 519, 0, 2443, 2444, 3, 1033, 516, 0, 2444, 2445, 3, 1053, 526, 0, 2445, 2446, 3, 1055, 527, 0, 2446, 2447, 3, 1059, 529, 0, 2447, 2448, 3, 1033, 516, 0, 2448, 2449, 3, 1025, 512, 0, 2449, 2450, 3, 1061, 530, 0, 2450, 300, 1, 0, 0, 0, 2451, 2452, 3, 1029, 514, 0, 2452, 2453, 3, 1017, 508, 0, 2453, 2454, 3, 1039, 519, 0, 2454, 2455, 3, 1039, 519, 0, 2455, 2456, 3, 1025, 512, 0, 2456, 2457, 3, 1051, 525, 0, 2457, 2458, 3, 1065, 532, 0, 2458, 302, 1, 0, 0, 0, 2459, 2460, 3, 1021, 510, 0, 2460, 2461, 3, 1045, 522, 0, 2461, 2462, 3, 1043, 521, 0, 2462, 2463, 3, 1055, 527, 0, 2463, 2464, 3, 1017, 508, 0, 2464, 2465, 3, 1033, 516, 0, 2465, 2466, 3, 1043, 521, 0, 2466, 2467, 3, 1025, 512, 0, 2467, 2468, 3, 1051, 525, 0, 2468, 304, 1, 0, 0, 0, 2469, 2470, 3, 1051, 525, 0, 2470, 2471, 3, 1045, 522, 0, 2471, 2472, 3, 1061, 530, 0, 2472, 306, 1, 0, 0, 0, 2473, 2474, 3, 1033, 516, 0, 2474, 2475, 3, 1055, 527, 0, 2475, 2476, 3, 1025, 512, 0, 2476, 2477, 3, 1041, 520, 0, 2477, 308, 1, 0, 0, 0, 2478, 2479, 3, 1021, 510, 0, 2479, 2480, 3, 1045, 522, 0, 2480, 2481, 3, 1043, 521, 0, 2481, 2482, 3, 1055, 527, 0, 2482, 2483, 3, 1051, 525, 0, 2483, 2484, 3, 1045, 522, 0, 2484, 2485, 3, 1039, 519, 0, 2485, 2486, 3, 1019, 509, 0, 2486, 2487, 3, 1017, 508, 0, 2487, 2488, 3, 1051, 525, 0, 2488, 310, 1, 0, 0, 0, 2489, 2490, 3, 1053, 526, 0, 2490, 2491, 3, 1025, 512, 0, 2491, 2492, 3, 1017, 508, 0, 2492, 2493, 3, 1051, 525, 0, 2493, 2494, 3, 1021, 510, 0, 2494, 2495, 3, 1031, 515, 0, 2495, 312, 1, 0, 0, 0, 2496, 2497, 3, 1053, 526, 0, 2497, 2498, 3, 1025, 512, 0, 2498, 2499, 3, 1017, 508, 0, 2499, 2500, 3, 1051, 525, 0, 2500, 2501, 3, 1021, 510, 0, 2501, 2502, 3, 1031, 515, 0, 2502, 2503, 3, 1019, 509, 0, 2503, 2504, 3, 1017, 508, 0, 2504, 2505, 3, 1051, 525, 0, 2505, 314, 1, 0, 0, 0, 2506, 2507, 3, 1043, 521, 0, 2507, 2508, 3, 1017, 508, 0, 2508, 2509, 3, 1059, 529, 0, 2509, 2510, 3, 1033, 516, 0, 2510, 2511, 3, 1029, 514, 0, 2511, 2512, 3, 1017, 508, 0, 2512, 2513, 3, 1055, 527, 0, 2513, 2514, 3, 1033, 516, 0, 2514, 2515, 3, 1045, 522, 0, 2515, 2516, 3, 1043, 521, 0, 2516, 2517, 3, 1039, 519, 0, 2517, 2518, 3, 1033, 516, 0, 2518, 2519, 3, 1053, 526, 0, 2519, 2520, 3, 1055, 527, 0, 2520, 316, 1, 0, 0, 0, 2521, 2522, 3, 1017, 508, 0, 2522, 2523, 3, 1021, 510, 0, 2523, 2524, 3, 1055, 527, 0, 2524, 2525, 3, 1033, 516, 0, 2525, 2526, 3, 1045, 522, 0, 2526, 2527, 3, 1043, 521, 0, 2527, 2528, 3, 1019, 509, 0, 2528, 2529, 3, 1057, 528, 0, 2529, 2530, 3, 1055, 527, 0, 2530, 2531, 3, 1055, 527, 0, 2531, 2532, 3, 1045, 522, 0, 2532, 2533, 3, 1043, 521, 0, 2533, 318, 1, 0, 0, 0, 2534, 2535, 3, 1039, 519, 0, 2535, 2536, 3, 1033, 516, 0, 2536, 2537, 3, 1043, 521, 0, 2537, 2538, 3, 1037, 518, 0, 2538, 2539, 3, 1019, 509, 0, 2539, 2540, 3, 1057, 528, 0, 2540, 2541, 3, 1055, 527, 0, 2541, 2542, 3, 1055, 527, 0, 2542, 2543, 3, 1045, 522, 0, 2543, 2544, 3, 1043, 521, 0, 2544, 320, 1, 0, 0, 0, 2545, 2546, 3, 1019, 509, 0, 2546, 2547, 3, 1057, 528, 0, 2547, 2548, 3, 1055, 527, 0, 2548, 2549, 3, 1055, 527, 0, 2549, 2550, 3, 1045, 522, 0, 2550, 2551, 3, 1043, 521, 0, 2551, 322, 1, 0, 0, 0, 2552, 2553, 3, 1055, 527, 0, 2553, 2554, 3, 1033, 516, 0, 2554, 2555, 3, 1055, 527, 0, 2555, 2556, 3, 1039, 519, 0, 2556, 2557, 3, 1025, 512, 0, 2557, 324, 1, 0, 0, 0, 2558, 2559, 3, 1023, 511, 0, 2559, 2560, 3, 1065, 532, 0, 2560, 2561, 3, 1043, 521, 0, 2561, 2562, 3, 1017, 508, 0, 2562, 2563, 3, 1041, 520, 0, 2563, 2564, 3, 1033, 516, 0, 2564, 2565, 3, 1021, 510, 0, 2565, 2566, 3, 1055, 527, 0, 2566, 2567, 3, 1025, 512, 0, 2567, 2568, 3, 1063, 531, 0, 2568, 2569, 3, 1055, 527, 0, 2569, 326, 1, 0, 0, 0, 2570, 2571, 3, 1023, 511, 0, 2571, 2572, 3, 1065, 532, 0, 2572, 2573, 3, 1043, 521, 0, 2573, 2574, 3, 1017, 508, 0, 2574, 2575, 3, 1041, 520, 0, 2575, 2576, 3, 1033, 516, 0, 2576, 2577, 3, 1021, 510, 0, 2577, 328, 1, 0, 0, 0, 2578, 2579, 3, 1053, 526, 0, 2579, 2580, 3, 1055, 527, 0, 2580, 2581, 3, 1017, 508, 0, 2581, 2582, 3, 1055, 527, 0, 2582, 2583, 3, 1033, 516, 0, 2583, 2584, 3, 1021, 510, 0, 2584, 2585, 3, 1055, 527, 0, 2585, 2586, 3, 1025, 512, 0, 2586, 2587, 3, 1063, 531, 0, 2587, 2588, 3, 1055, 527, 0, 2588, 330, 1, 0, 0, 0, 2589, 2590, 3, 1039, 519, 0, 2590, 2591, 3, 1017, 508, 0, 2591, 2592, 3, 1019, 509, 0, 2592, 2593, 3, 1025, 512, 0, 2593, 2594, 3, 1039, 519, 0, 2594, 332, 1, 0, 0, 0, 2595, 2596, 3, 1055, 527, 0, 2596, 2597, 3, 1025, 512, 0, 2597, 2598, 3, 1063, 531, 0, 2598, 2599, 3, 1055, 527, 0, 2599, 2600, 3, 1019, 509, 0, 2600, 2601, 3, 1045, 522, 0, 2601, 2602, 3, 1063, 531, 0, 2602, 334, 1, 0, 0, 0, 2603, 2604, 3, 1055, 527, 0, 2604, 2605, 3, 1025, 512, 0, 2605, 2606, 3, 1063, 531, 0, 2606, 2607, 3, 1055, 527, 0, 2607, 2608, 3, 1017, 508, 0, 2608, 2609, 3, 1051, 525, 0, 2609, 2610, 3, 1025, 512, 0, 2610, 2611, 3, 1017, 508, 0, 2611, 336, 1, 0, 0, 0, 2612, 2613, 3, 1023, 511, 0, 2613, 2614, 3, 1017, 508, 0, 2614, 2615, 3, 1055, 527, 0, 2615, 2616, 3, 1025, 512, 0, 2616, 2617, 3, 1047, 523, 0, 2617, 2618, 3, 1033, 516, 0, 2618, 2619, 3, 1021, 510, 0, 2619, 2620, 3, 1037, 518, 0, 2620, 2621, 3, 1025, 512, 0, 2621, 2622, 3, 1051, 525, 0, 2622, 338, 1, 0, 0, 0, 2623, 2624, 3, 1051, 525, 0, 2624, 2625, 3, 1017, 508, 0, 2625, 2626, 3, 1023, 511, 0, 2626, 2627, 3, 1033, 516, 0, 2627, 2628, 3, 1045, 522, 0, 2628, 2629, 3, 1019, 509, 0, 2629, 2630, 3, 1057, 528, 0, 2630, 2631, 3, 1055, 527, 0, 2631, 2632, 3, 1055, 527, 0, 2632, 2633, 3, 1045, 522, 0, 2633, 2634, 3, 1043, 521, 0, 2634, 2635, 3, 1053, 526, 0, 2635, 340, 1, 0, 0, 0, 2636, 2637, 3, 1023, 511, 0, 2637, 2638, 3, 1051, 525, 0, 2638, 2639, 3, 1045, 522, 0, 2639, 2640, 3, 1047, 523, 0, 2640, 2641, 3, 1023, 511, 0, 2641, 2642, 3, 1045, 522, 0, 2642, 2643, 3, 1061, 530, 0, 2643, 2644, 3, 1043, 521, 0, 2644, 342, 1, 0, 0, 0, 2645, 2646, 3, 1021, 510, 0, 2646, 2647, 3, 1045, 522, 0, 2647, 2648, 3, 1041, 520, 0, 2648, 2649, 3, 1019, 509, 0, 2649, 2650, 3, 1045, 522, 0, 2650, 2651, 3, 1019, 509, 0, 2651, 2652, 3, 1045, 522, 0, 2652, 2653, 3, 1063, 531, 0, 2653, 344, 1, 0, 0, 0, 2654, 2655, 3, 1021, 510, 0, 2655, 2656, 3, 1031, 515, 0, 2656, 2657, 3, 1025, 512, 0, 2657, 2658, 3, 1021, 510, 0, 2658, 2659, 3, 1037, 518, 0, 2659, 2660, 3, 1019, 509, 0, 2660, 2661, 3, 1045, 522, 0, 2661, 2662, 3, 1063, 531, 0, 2662, 346, 1, 0, 0, 0, 2663, 2664, 3, 1051, 525, 0, 2664, 2665, 3, 1025, 512, 0, 2665, 2666, 3, 1027, 513, 0, 2666, 2667, 3, 1025, 512, 0, 2667, 2668, 3, 1051, 525, 0, 2668, 2669, 3, 1025, 512, 0, 2669, 2670, 3, 1043, 521, 0, 2670, 2671, 3, 1021, 510, 0, 2671, 2672, 3, 1025, 512, 0, 2672, 2673, 3, 1053, 526, 0, 2673, 2674, 3, 1025, 512, 0, 2674, 2675, 3, 1039, 519, 0, 2675, 2676, 3, 1025, 512, 0, 2676, 2677, 3, 1021, 510, 0, 2677, 2678, 3, 1055, 527, 0, 2678, 2679, 3, 1045, 522, 0, 2679, 2680, 3, 1051, 525, 0, 2680, 348, 1, 0, 0, 0, 2681, 2682, 3, 1033, 516, 0, 2682, 2683, 3, 1043, 521, 0, 2683, 2684, 3, 1047, 523, 0, 2684, 2685, 3, 1057, 528, 0, 2685, 2686, 3, 1055, 527, 0, 2686, 2687, 3, 1051, 525, 0, 2687, 2688, 3, 1025, 512, 0, 2688, 2689, 3, 1027, 513, 0, 2689, 2690, 3, 1025, 512, 0, 2690, 2691, 3, 1051, 525, 0, 2691, 2692, 3, 1025, 512, 0, 2692, 2693, 3, 1043, 521, 0, 2693, 2694, 3, 1021, 510, 0, 2694, 2695, 3, 1025, 512, 0, 2695, 2696, 3, 1053, 526, 0, 2696, 2697, 3, 1025, 512, 0, 2697, 2698, 3, 1055, 527, 0, 2698, 2699, 3, 1053, 526, 0, 2699, 2700, 3, 1025, 512, 0, 2700, 2701, 3, 1039, 519, 0, 2701, 2702, 3, 1025, 512, 0, 2702, 2703, 3, 1021, 510, 0, 2703, 2704, 3, 1055, 527, 0, 2704, 2705, 3, 1045, 522, 0, 2705, 2706, 3, 1051, 525, 0, 2706, 350, 1, 0, 0, 0, 2707, 2708, 3, 1027, 513, 0, 2708, 2709, 3, 1033, 516, 0, 2709, 2710, 3, 1039, 519, 0, 2710, 2711, 3, 1025, 512, 0, 2711, 2712, 3, 1033, 516, 0, 2712, 2713, 3, 1043, 521, 0, 2713, 2714, 3, 1047, 523, 0, 2714, 2715, 3, 1057, 528, 0, 2715, 2716, 3, 1055, 527, 0, 2716, 352, 1, 0, 0, 0, 2717, 2718, 3, 1033, 516, 0, 2718, 2719, 3, 1041, 520, 0, 2719, 2720, 3, 1017, 508, 0, 2720, 2721, 3, 1029, 514, 0, 2721, 2722, 3, 1025, 512, 0, 2722, 2723, 3, 1033, 516, 0, 2723, 2724, 3, 1043, 521, 0, 2724, 2725, 3, 1047, 523, 0, 2725, 2726, 3, 1057, 528, 0, 2726, 2727, 3, 1055, 527, 0, 2727, 354, 1, 0, 0, 0, 2728, 2729, 3, 1021, 510, 0, 2729, 2730, 3, 1057, 528, 0, 2730, 2731, 3, 1053, 526, 0, 2731, 2732, 3, 1055, 527, 0, 2732, 2733, 3, 1045, 522, 0, 2733, 2734, 3, 1041, 520, 0, 2734, 2735, 3, 1061, 530, 0, 2735, 2736, 3, 1033, 516, 0, 2736, 2737, 3, 1023, 511, 0, 2737, 2738, 3, 1029, 514, 0, 2738, 2739, 3, 1025, 512, 0, 2739, 2740, 3, 1055, 527, 0, 2740, 356, 1, 0, 0, 0, 2741, 2742, 3, 1055, 527, 0, 2742, 2743, 3, 1025, 512, 0, 2743, 2744, 3, 1063, 531, 0, 2744, 2745, 3, 1055, 527, 0, 2745, 2746, 3, 1027, 513, 0, 2746, 2747, 3, 1033, 516, 0, 2747, 2748, 3, 1039, 519, 0, 2748, 2749, 3, 1055, 527, 0, 2749, 2750, 3, 1025, 512, 0, 2750, 2751, 3, 1051, 525, 0, 2751, 358, 1, 0, 0, 0, 2752, 2753, 3, 1043, 521, 0, 2753, 2754, 3, 1057, 528, 0, 2754, 2755, 3, 1041, 520, 0, 2755, 2756, 3, 1019, 509, 0, 2756, 2757, 3, 1025, 512, 0, 2757, 2758, 3, 1051, 525, 0, 2758, 2759, 3, 1027, 513, 0, 2759, 2760, 3, 1033, 516, 0, 2760, 2761, 3, 1039, 519, 0, 2761, 2762, 3, 1055, 527, 0, 2762, 2763, 3, 1025, 512, 0, 2763, 2764, 3, 1051, 525, 0, 2764, 360, 1, 0, 0, 0, 2765, 2766, 3, 1023, 511, 0, 2766, 2767, 3, 1051, 525, 0, 2767, 2768, 3, 1045, 522, 0, 2768, 2769, 3, 1047, 523, 0, 2769, 2770, 3, 1023, 511, 0, 2770, 2771, 3, 1045, 522, 0, 2771, 2772, 3, 1061, 530, 0, 2772, 2773, 3, 1043, 521, 0, 2773, 2774, 3, 1027, 513, 0, 2774, 2775, 3, 1033, 516, 0, 2775, 2776, 3, 1039, 519, 0, 2776, 2777, 3, 1055, 527, 0, 2777, 2778, 3, 1025, 512, 0, 2778, 2779, 3, 1051, 525, 0, 2779, 362, 1, 0, 0, 0, 2780, 2781, 3, 1023, 511, 0, 2781, 2782, 3, 1017, 508, 0, 2782, 2783, 3, 1055, 527, 0, 2783, 2784, 3, 1025, 512, 0, 2784, 2785, 3, 1027, 513, 0, 2785, 2786, 3, 1033, 516, 0, 2786, 2787, 3, 1039, 519, 0, 2787, 2788, 3, 1055, 527, 0, 2788, 2789, 3, 1025, 512, 0, 2789, 2790, 3, 1051, 525, 0, 2790, 364, 1, 0, 0, 0, 2791, 2792, 3, 1027, 513, 0, 2792, 2793, 3, 1033, 516, 0, 2793, 2794, 3, 1039, 519, 0, 2794, 2795, 3, 1055, 527, 0, 2795, 2796, 3, 1025, 512, 0, 2796, 2797, 3, 1051, 525, 0, 2797, 366, 1, 0, 0, 0, 2798, 2799, 3, 1061, 530, 0, 2799, 2800, 3, 1033, 516, 0, 2800, 2801, 3, 1023, 511, 0, 2801, 2802, 3, 1029, 514, 0, 2802, 2803, 3, 1025, 512, 0, 2803, 2804, 3, 1055, 527, 0, 2804, 368, 1, 0, 0, 0, 2805, 2806, 3, 1061, 530, 0, 2806, 2807, 3, 1033, 516, 0, 2807, 2808, 3, 1023, 511, 0, 2808, 2809, 3, 1029, 514, 0, 2809, 2810, 3, 1025, 512, 0, 2810, 2811, 3, 1055, 527, 0, 2811, 2812, 3, 1053, 526, 0, 2812, 370, 1, 0, 0, 0, 2813, 2814, 3, 1021, 510, 0, 2814, 2815, 3, 1017, 508, 0, 2815, 2816, 3, 1047, 523, 0, 2816, 2817, 3, 1055, 527, 0, 2817, 2818, 3, 1033, 516, 0, 2818, 2819, 3, 1045, 522, 0, 2819, 2820, 3, 1043, 521, 0, 2820, 372, 1, 0, 0, 0, 2821, 2822, 3, 1033, 516, 0, 2822, 2823, 3, 1021, 510, 0, 2823, 2824, 3, 1045, 522, 0, 2824, 2825, 3, 1043, 521, 0, 2825, 374, 1, 0, 0, 0, 2826, 2827, 3, 1055, 527, 0, 2827, 2828, 3, 1045, 522, 0, 2828, 2829, 3, 1045, 522, 0, 2829, 2830, 3, 1039, 519, 0, 2830, 2831, 3, 1055, 527, 0, 2831, 2832, 3, 1033, 516, 0, 2832, 2833, 3, 1047, 523, 0, 2833, 376, 1, 0, 0, 0, 2834, 2835, 3, 1023, 511, 0, 2835, 2836, 3, 1017, 508, 0, 2836, 2837, 3, 1055, 527, 0, 2837, 2838, 3, 1017, 508, 0, 2838, 2839, 3, 1053, 526, 0, 2839, 2840, 3, 1045, 522, 0, 2840, 2841, 3, 1057, 528, 0, 2841, 2842, 3, 1051, 525, 0, 2842, 2843, 3, 1021, 510, 0, 2843, 2844, 3, 1025, 512, 0, 2844, 378, 1, 0, 0, 0, 2845, 2846, 3, 1053, 526, 0, 2846, 2847, 3, 1045, 522, 0, 2847, 2848, 3, 1057, 528, 0, 2848, 2849, 3, 1051, 525, 0, 2849, 2850, 3, 1021, 510, 0, 2850, 2851, 3, 1025, 512, 0, 2851, 380, 1, 0, 0, 0, 2852, 2853, 3, 1053, 526, 0, 2853, 2854, 3, 1025, 512, 0, 2854, 2855, 3, 1039, 519, 0, 2855, 2856, 3, 1025, 512, 0, 2856, 2857, 3, 1021, 510, 0, 2857, 2858, 3, 1055, 527, 0, 2858, 2859, 3, 1033, 516, 0, 2859, 2860, 3, 1045, 522, 0, 2860, 2861, 3, 1043, 521, 0, 2861, 382, 1, 0, 0, 0, 2862, 2863, 3, 1027, 513, 0, 2863, 2864, 3, 1045, 522, 0, 2864, 2865, 3, 1045, 522, 0, 2865, 2866, 3, 1055, 527, 0, 2866, 2867, 3, 1025, 512, 0, 2867, 2868, 3, 1051, 525, 0, 2868, 384, 1, 0, 0, 0, 2869, 2870, 3, 1031, 515, 0, 2870, 2871, 3, 1025, 512, 0, 2871, 2872, 3, 1017, 508, 0, 2872, 2873, 3, 1023, 511, 0, 2873, 2874, 3, 1025, 512, 0, 2874, 2875, 3, 1051, 525, 0, 2875, 386, 1, 0, 0, 0, 2876, 2877, 3, 1021, 510, 0, 2877, 2878, 3, 1045, 522, 0, 2878, 2879, 3, 1043, 521, 0, 2879, 2880, 3, 1055, 527, 0, 2880, 2881, 3, 1025, 512, 0, 2881, 2882, 3, 1043, 521, 0, 2882, 2883, 3, 1055, 527, 0, 2883, 388, 1, 0, 0, 0, 2884, 2885, 3, 1051, 525, 0, 2885, 2886, 3, 1025, 512, 0, 2886, 2887, 3, 1043, 521, 0, 2887, 2888, 3, 1023, 511, 0, 2888, 2889, 3, 1025, 512, 0, 2889, 2890, 3, 1051, 525, 0, 2890, 2891, 3, 1041, 520, 0, 2891, 2892, 3, 1045, 522, 0, 2892, 2893, 3, 1023, 511, 0, 2893, 2894, 3, 1025, 512, 0, 2894, 390, 1, 0, 0, 0, 2895, 2896, 3, 1019, 509, 0, 2896, 2897, 3, 1033, 516, 0, 2897, 2898, 3, 1043, 521, 0, 2898, 2899, 3, 1023, 511, 0, 2899, 2900, 3, 1053, 526, 0, 2900, 392, 1, 0, 0, 0, 2901, 2902, 3, 1017, 508, 0, 2902, 2903, 3, 1055, 527, 0, 2903, 2904, 3, 1055, 527, 0, 2904, 2905, 3, 1051, 525, 0, 2905, 394, 1, 0, 0, 0, 2906, 2907, 3, 1021, 510, 0, 2907, 2908, 3, 1045, 522, 0, 2908, 2909, 3, 1043, 521, 0, 2909, 2910, 3, 1055, 527, 0, 2910, 2911, 3, 1025, 512, 0, 2911, 2912, 3, 1043, 521, 0, 2912, 2913, 3, 1055, 527, 0, 2913, 2914, 3, 1047, 523, 0, 2914, 2915, 3, 1017, 508, 0, 2915, 2916, 3, 1051, 525, 0, 2916, 2917, 3, 1017, 508, 0, 2917, 2918, 3, 1041, 520, 0, 2918, 2919, 3, 1053, 526, 0, 2919, 396, 1, 0, 0, 0, 2920, 2921, 3, 1021, 510, 0, 2921, 2922, 3, 1017, 508, 0, 2922, 2923, 3, 1047, 523, 0, 2923, 2924, 3, 1055, 527, 0, 2924, 2925, 3, 1033, 516, 0, 2925, 2926, 3, 1045, 522, 0, 2926, 2927, 3, 1043, 521, 0, 2927, 2928, 3, 1047, 523, 0, 2928, 2929, 3, 1017, 508, 0, 2929, 2930, 3, 1051, 525, 0, 2930, 2931, 3, 1017, 508, 0, 2931, 2932, 3, 1041, 520, 0, 2932, 2933, 3, 1053, 526, 0, 2933, 398, 1, 0, 0, 0, 2934, 2935, 3, 1047, 523, 0, 2935, 2936, 3, 1017, 508, 0, 2936, 2937, 3, 1051, 525, 0, 2937, 2938, 3, 1017, 508, 0, 2938, 2939, 3, 1041, 520, 0, 2939, 2940, 3, 1053, 526, 0, 2940, 400, 1, 0, 0, 0, 2941, 2942, 3, 1059, 529, 0, 2942, 2943, 3, 1017, 508, 0, 2943, 2944, 3, 1051, 525, 0, 2944, 2945, 3, 1033, 516, 0, 2945, 2946, 3, 1017, 508, 0, 2946, 2947, 3, 1019, 509, 0, 2947, 2948, 3, 1039, 519, 0, 2948, 2949, 3, 1025, 512, 0, 2949, 2950, 3, 1053, 526, 0, 2950, 402, 1, 0, 0, 0, 2951, 2952, 3, 1023, 511, 0, 2952, 2953, 3, 1025, 512, 0, 2953, 2954, 3, 1053, 526, 0, 2954, 2955, 3, 1037, 518, 0, 2955, 2956, 3, 1055, 527, 0, 2956, 2957, 3, 1045, 522, 0, 2957, 2958, 3, 1047, 523, 0, 2958, 2959, 3, 1061, 530, 0, 2959, 2960, 3, 1033, 516, 0, 2960, 2961, 3, 1023, 511, 0, 2961, 2962, 3, 1055, 527, 0, 2962, 2963, 3, 1031, 515, 0, 2963, 404, 1, 0, 0, 0, 2964, 2965, 3, 1021, 510, 0, 2965, 2966, 3, 1039, 519, 0, 2966, 2967, 3, 1017, 508, 0, 2967, 2968, 3, 1053, 526, 0, 2968, 2969, 3, 1053, 526, 0, 2969, 406, 1, 0, 0, 0, 2970, 2971, 3, 1053, 526, 0, 2971, 2972, 3, 1055, 527, 0, 2972, 2973, 3, 1065, 532, 0, 2973, 2974, 3, 1039, 519, 0, 2974, 2975, 3, 1025, 512, 0, 2975, 408, 1, 0, 0, 0, 2976, 2977, 3, 1019, 509, 0, 2977, 2978, 3, 1057, 528, 0, 2978, 2979, 3, 1055, 527, 0, 2979, 2980, 3, 1055, 527, 0, 2980, 2981, 3, 1045, 522, 0, 2981, 2982, 3, 1043, 521, 0, 2982, 2983, 3, 1053, 526, 0, 2983, 2984, 3, 1055, 527, 0, 2984, 2985, 3, 1065, 532, 0, 2985, 2986, 3, 1039, 519, 0, 2986, 2987, 3, 1025, 512, 0, 2987, 410, 1, 0, 0, 0, 2988, 2989, 3, 1023, 511, 0, 2989, 2990, 3, 1025, 512, 0, 2990, 2991, 3, 1053, 526, 0, 2991, 2992, 3, 1033, 516, 0, 2992, 2993, 3, 1029, 514, 0, 2993, 2994, 3, 1043, 521, 0, 2994, 412, 1, 0, 0, 0, 2995, 2996, 3, 1047, 523, 0, 2996, 2997, 3, 1051, 525, 0, 2997, 2998, 3, 1045, 522, 0, 2998, 2999, 3, 1047, 523, 0, 2999, 3000, 3, 1025, 512, 0, 3000, 3001, 3, 1051, 525, 0, 3001, 3002, 3, 1055, 527, 0, 3002, 3003, 3, 1033, 516, 0, 3003, 3004, 3, 1025, 512, 0, 3004, 3005, 3, 1053, 526, 0, 3005, 414, 1, 0, 0, 0, 3006, 3007, 3, 1023, 511, 0, 3007, 3008, 3, 1025, 512, 0, 3008, 3009, 3, 1053, 526, 0, 3009, 3010, 3, 1033, 516, 0, 3010, 3011, 3, 1029, 514, 0, 3011, 3012, 3, 1043, 521, 0, 3012, 3013, 3, 1047, 523, 0, 3013, 3014, 3, 1051, 525, 0, 3014, 3015, 3, 1045, 522, 0, 3015, 3016, 3, 1047, 523, 0, 3016, 3017, 3, 1025, 512, 0, 3017, 3018, 3, 1051, 525, 0, 3018, 3019, 3, 1055, 527, 0, 3019, 3020, 3, 1033, 516, 0, 3020, 3021, 3, 1025, 512, 0, 3021, 3022, 3, 1053, 526, 0, 3022, 416, 1, 0, 0, 0, 3023, 3024, 3, 1053, 526, 0, 3024, 3025, 3, 1055, 527, 0, 3025, 3026, 3, 1065, 532, 0, 3026, 3027, 3, 1039, 519, 0, 3027, 3028, 3, 1033, 516, 0, 3028, 3029, 3, 1043, 521, 0, 3029, 3030, 3, 1029, 514, 0, 3030, 418, 1, 0, 0, 0, 3031, 3032, 3, 1021, 510, 0, 3032, 3033, 3, 1039, 519, 0, 3033, 3034, 3, 1025, 512, 0, 3034, 3035, 3, 1017, 508, 0, 3035, 3036, 3, 1051, 525, 0, 3036, 420, 1, 0, 0, 0, 3037, 3038, 3, 1061, 530, 0, 3038, 3039, 3, 1033, 516, 0, 3039, 3040, 3, 1023, 511, 0, 3040, 3041, 3, 1055, 527, 0, 3041, 3042, 3, 1031, 515, 0, 3042, 422, 1, 0, 0, 0, 3043, 3044, 3, 1031, 515, 0, 3044, 3045, 3, 1025, 512, 0, 3045, 3046, 3, 1033, 516, 0, 3046, 3047, 3, 1029, 514, 0, 3047, 3048, 3, 1031, 515, 0, 3048, 3049, 3, 1055, 527, 0, 3049, 424, 1, 0, 0, 0, 3050, 3051, 3, 1017, 508, 0, 3051, 3052, 3, 1057, 528, 0, 3052, 3053, 3, 1055, 527, 0, 3053, 3054, 3, 1045, 522, 0, 3054, 3055, 3, 1027, 513, 0, 3055, 3056, 3, 1033, 516, 0, 3056, 3057, 3, 1039, 519, 0, 3057, 3058, 3, 1039, 519, 0, 3058, 426, 1, 0, 0, 0, 3059, 3060, 3, 1057, 528, 0, 3060, 3061, 3, 1051, 525, 0, 3061, 3062, 3, 1039, 519, 0, 3062, 428, 1, 0, 0, 0, 3063, 3064, 3, 1027, 513, 0, 3064, 3065, 3, 1045, 522, 0, 3065, 3066, 3, 1039, 519, 0, 3066, 3067, 3, 1023, 511, 0, 3067, 3068, 3, 1025, 512, 0, 3068, 3069, 3, 1051, 525, 0, 3069, 430, 1, 0, 0, 0, 3070, 3071, 3, 1047, 523, 0, 3071, 3072, 3, 1017, 508, 0, 3072, 3073, 3, 1053, 526, 0, 3073, 3074, 3, 1053, 526, 0, 3074, 3075, 3, 1033, 516, 0, 3075, 3076, 3, 1043, 521, 0, 3076, 3077, 3, 1029, 514, 0, 3077, 432, 1, 0, 0, 0, 3078, 3079, 3, 1021, 510, 0, 3079, 3080, 3, 1045, 522, 0, 3080, 3081, 3, 1043, 521, 0, 3081, 3082, 3, 1055, 527, 0, 3082, 3083, 3, 1025, 512, 0, 3083, 3084, 3, 1063, 531, 0, 3084, 3085, 3, 1055, 527, 0, 3085, 434, 1, 0, 0, 0, 3086, 3087, 3, 1025, 512, 0, 3087, 3088, 3, 1023, 511, 0, 3088, 3089, 3, 1033, 516, 0, 3089, 3090, 3, 1055, 527, 0, 3090, 3091, 3, 1017, 508, 0, 3091, 3092, 3, 1019, 509, 0, 3092, 3093, 3, 1039, 519, 0, 3093, 3094, 3, 1025, 512, 0, 3094, 436, 1, 0, 0, 0, 3095, 3096, 3, 1051, 525, 0, 3096, 3097, 3, 1025, 512, 0, 3097, 3098, 3, 1017, 508, 0, 3098, 3099, 3, 1023, 511, 0, 3099, 3100, 3, 1045, 522, 0, 3100, 3101, 3, 1043, 521, 0, 3101, 3102, 3, 1039, 519, 0, 3102, 3103, 3, 1065, 532, 0, 3103, 438, 1, 0, 0, 0, 3104, 3105, 3, 1017, 508, 0, 3105, 3106, 3, 1055, 527, 0, 3106, 3107, 3, 1055, 527, 0, 3107, 3108, 3, 1051, 525, 0, 3108, 3109, 3, 1033, 516, 0, 3109, 3110, 3, 1019, 509, 0, 3110, 3111, 3, 1057, 528, 0, 3111, 3112, 3, 1055, 527, 0, 3112, 3113, 3, 1025, 512, 0, 3113, 3114, 3, 1053, 526, 0, 3114, 440, 1, 0, 0, 0, 3115, 3116, 3, 1027, 513, 0, 3116, 3117, 3, 1033, 516, 0, 3117, 3118, 3, 1039, 519, 0, 3118, 3119, 3, 1055, 527, 0, 3119, 3120, 3, 1025, 512, 0, 3120, 3121, 3, 1051, 525, 0, 3121, 3122, 3, 1055, 527, 0, 3122, 3123, 3, 1065, 532, 0, 3123, 3124, 3, 1047, 523, 0, 3124, 3125, 3, 1025, 512, 0, 3125, 442, 1, 0, 0, 0, 3126, 3127, 3, 1033, 516, 0, 3127, 3128, 3, 1041, 520, 0, 3128, 3129, 3, 1017, 508, 0, 3129, 3130, 3, 1029, 514, 0, 3130, 3131, 3, 1025, 512, 0, 3131, 444, 1, 0, 0, 0, 3132, 3133, 3, 1053, 526, 0, 3133, 3134, 3, 1055, 527, 0, 3134, 3135, 3, 1017, 508, 0, 3135, 3136, 3, 1055, 527, 0, 3136, 3137, 3, 1033, 516, 0, 3137, 3138, 3, 1021, 510, 0, 3138, 3139, 3, 1033, 516, 0, 3139, 3140, 3, 1041, 520, 0, 3140, 3141, 3, 1017, 508, 0, 3141, 3142, 3, 1029, 514, 0, 3142, 3143, 3, 1025, 512, 0, 3143, 446, 1, 0, 0, 0, 3144, 3145, 3, 1023, 511, 0, 3145, 3146, 3, 1065, 532, 0, 3146, 3147, 3, 1043, 521, 0, 3147, 3148, 3, 1017, 508, 0, 3148, 3149, 3, 1041, 520, 0, 3149, 3150, 3, 1033, 516, 0, 3150, 3151, 3, 1021, 510, 0, 3151, 3152, 3, 1033, 516, 0, 3152, 3153, 3, 1041, 520, 0, 3153, 3154, 3, 1017, 508, 0, 3154, 3155, 3, 1029, 514, 0, 3155, 3156, 3, 1025, 512, 0, 3156, 448, 1, 0, 0, 0, 3157, 3158, 3, 1021, 510, 0, 3158, 3159, 3, 1057, 528, 0, 3159, 3160, 3, 1053, 526, 0, 3160, 3161, 3, 1055, 527, 0, 3161, 3162, 3, 1045, 522, 0, 3162, 3163, 3, 1041, 520, 0, 3163, 3164, 3, 1021, 510, 0, 3164, 3165, 3, 1045, 522, 0, 3165, 3166, 3, 1043, 521, 0, 3166, 3167, 3, 1055, 527, 0, 3167, 3168, 3, 1017, 508, 0, 3168, 3169, 3, 1033, 516, 0, 3169, 3170, 3, 1043, 521, 0, 3170, 3171, 3, 1025, 512, 0, 3171, 3172, 3, 1051, 525, 0, 3172, 450, 1, 0, 0, 0, 3173, 3174, 3, 1029, 514, 0, 3174, 3175, 3, 1051, 525, 0, 3175, 3176, 3, 1045, 522, 0, 3176, 3177, 3, 1057, 528, 0, 3177, 3178, 3, 1047, 523, 0, 3178, 3179, 3, 1019, 509, 0, 3179, 3180, 3, 1045, 522, 0, 3180, 3181, 3, 1063, 531, 0, 3181, 452, 1, 0, 0, 0, 3182, 3183, 3, 1059, 529, 0, 3183, 3184, 3, 1033, 516, 0, 3184, 3185, 3, 1053, 526, 0, 3185, 3186, 3, 1033, 516, 0, 3186, 3187, 3, 1019, 509, 0, 3187, 3188, 3, 1039, 519, 0, 3188, 3189, 3, 1025, 512, 0, 3189, 454, 1, 0, 0, 0, 3190, 3191, 3, 1053, 526, 0, 3191, 3192, 3, 1017, 508, 0, 3192, 3193, 3, 1059, 529, 0, 3193, 3194, 3, 1025, 512, 0, 3194, 3195, 3, 1021, 510, 0, 3195, 3196, 3, 1031, 515, 0, 3196, 3197, 3, 1017, 508, 0, 3197, 3198, 3, 1043, 521, 0, 3198, 3199, 3, 1029, 514, 0, 3199, 3200, 3, 1025, 512, 0, 3200, 3201, 3, 1053, 526, 0, 3201, 456, 1, 0, 0, 0, 3202, 3203, 3, 1053, 526, 0, 3203, 3204, 3, 1017, 508, 0, 3204, 3205, 3, 1059, 529, 0, 3205, 3206, 3, 1025, 512, 0, 3206, 3207, 5, 95, 0, 0, 3207, 3208, 3, 1021, 510, 0, 3208, 3209, 3, 1031, 515, 0, 3209, 3210, 3, 1017, 508, 0, 3210, 3211, 3, 1043, 521, 0, 3211, 3212, 3, 1029, 514, 0, 3212, 3213, 3, 1025, 512, 0, 3213, 3214, 3, 1053, 526, 0, 3214, 458, 1, 0, 0, 0, 3215, 3216, 3, 1021, 510, 0, 3216, 3217, 3, 1017, 508, 0, 3217, 3218, 3, 1043, 521, 0, 3218, 3219, 3, 1021, 510, 0, 3219, 3220, 3, 1025, 512, 0, 3220, 3221, 3, 1039, 519, 0, 3221, 3222, 5, 95, 0, 0, 3222, 3223, 3, 1021, 510, 0, 3223, 3224, 3, 1031, 515, 0, 3224, 3225, 3, 1017, 508, 0, 3225, 3226, 3, 1043, 521, 0, 3226, 3227, 3, 1029, 514, 0, 3227, 3228, 3, 1025, 512, 0, 3228, 3229, 3, 1053, 526, 0, 3229, 460, 1, 0, 0, 0, 3230, 3231, 3, 1021, 510, 0, 3231, 3232, 3, 1039, 519, 0, 3232, 3233, 3, 1045, 522, 0, 3233, 3234, 3, 1053, 526, 0, 3234, 3235, 3, 1025, 512, 0, 3235, 3236, 5, 95, 0, 0, 3236, 3237, 3, 1047, 523, 0, 3237, 3238, 3, 1017, 508, 0, 3238, 3239, 3, 1029, 514, 0, 3239, 3240, 3, 1025, 512, 0, 3240, 462, 1, 0, 0, 0, 3241, 3242, 3, 1053, 526, 0, 3242, 3243, 3, 1031, 515, 0, 3243, 3244, 3, 1045, 522, 0, 3244, 3245, 3, 1061, 530, 0, 3245, 3246, 5, 95, 0, 0, 3246, 3247, 3, 1047, 523, 0, 3247, 3248, 3, 1017, 508, 0, 3248, 3249, 3, 1029, 514, 0, 3249, 3250, 3, 1025, 512, 0, 3250, 464, 1, 0, 0, 0, 3251, 3252, 3, 1023, 511, 0, 3252, 3253, 3, 1025, 512, 0, 3253, 3254, 3, 1039, 519, 0, 3254, 3255, 3, 1025, 512, 0, 3255, 3256, 3, 1055, 527, 0, 3256, 3257, 3, 1025, 512, 0, 3257, 3258, 5, 95, 0, 0, 3258, 3259, 3, 1017, 508, 0, 3259, 3260, 3, 1021, 510, 0, 3260, 3261, 3, 1055, 527, 0, 3261, 3262, 3, 1033, 516, 0, 3262, 3263, 3, 1045, 522, 0, 3263, 3264, 3, 1043, 521, 0, 3264, 466, 1, 0, 0, 0, 3265, 3266, 3, 1023, 511, 0, 3266, 3267, 3, 1025, 512, 0, 3267, 3268, 3, 1039, 519, 0, 3268, 3269, 3, 1025, 512, 0, 3269, 3270, 3, 1055, 527, 0, 3270, 3271, 3, 1025, 512, 0, 3271, 3272, 5, 95, 0, 0, 3272, 3273, 3, 1045, 522, 0, 3273, 3274, 3, 1019, 509, 0, 3274, 3275, 3, 1035, 517, 0, 3275, 3276, 3, 1025, 512, 0, 3276, 3277, 3, 1021, 510, 0, 3277, 3278, 3, 1055, 527, 0, 3278, 468, 1, 0, 0, 0, 3279, 3280, 3, 1021, 510, 0, 3280, 3281, 3, 1051, 525, 0, 3281, 3282, 3, 1025, 512, 0, 3282, 3283, 3, 1017, 508, 0, 3283, 3284, 3, 1055, 527, 0, 3284, 3285, 3, 1025, 512, 0, 3285, 3286, 5, 95, 0, 0, 3286, 3287, 3, 1045, 522, 0, 3287, 3288, 3, 1019, 509, 0, 3288, 3289, 3, 1035, 517, 0, 3289, 3290, 3, 1025, 512, 0, 3290, 3291, 3, 1021, 510, 0, 3291, 3292, 3, 1055, 527, 0, 3292, 470, 1, 0, 0, 0, 3293, 3294, 3, 1021, 510, 0, 3294, 3295, 3, 1017, 508, 0, 3295, 3296, 3, 1039, 519, 0, 3296, 3297, 3, 1039, 519, 0, 3297, 3298, 5, 95, 0, 0, 3298, 3299, 3, 1041, 520, 0, 3299, 3300, 3, 1033, 516, 0, 3300, 3301, 3, 1021, 510, 0, 3301, 3302, 3, 1051, 525, 0, 3302, 3303, 3, 1045, 522, 0, 3303, 3304, 3, 1027, 513, 0, 3304, 3305, 3, 1039, 519, 0, 3305, 3306, 3, 1045, 522, 0, 3306, 3307, 3, 1061, 530, 0, 3307, 472, 1, 0, 0, 0, 3308, 3309, 3, 1021, 510, 0, 3309, 3310, 3, 1017, 508, 0, 3310, 3311, 3, 1039, 519, 0, 3311, 3312, 3, 1039, 519, 0, 3312, 3313, 5, 95, 0, 0, 3313, 3314, 3, 1043, 521, 0, 3314, 3315, 3, 1017, 508, 0, 3315, 3316, 3, 1043, 521, 0, 3316, 3317, 3, 1045, 522, 0, 3317, 3318, 3, 1027, 513, 0, 3318, 3319, 3, 1039, 519, 0, 3319, 3320, 3, 1045, 522, 0, 3320, 3321, 3, 1061, 530, 0, 3321, 474, 1, 0, 0, 0, 3322, 3323, 3, 1045, 522, 0, 3323, 3324, 3, 1047, 523, 0, 3324, 3325, 3, 1025, 512, 0, 3325, 3326, 3, 1043, 521, 0, 3326, 3327, 5, 95, 0, 0, 3327, 3328, 3, 1039, 519, 0, 3328, 3329, 3, 1033, 516, 0, 3329, 3330, 3, 1043, 521, 0, 3330, 3331, 3, 1037, 518, 0, 3331, 476, 1, 0, 0, 0, 3332, 3333, 3, 1053, 526, 0, 3333, 3334, 3, 1033, 516, 0, 3334, 3335, 3, 1029, 514, 0, 3335, 3336, 3, 1043, 521, 0, 3336, 3337, 5, 95, 0, 0, 3337, 3338, 3, 1045, 522, 0, 3338, 3339, 3, 1057, 528, 0, 3339, 3340, 3, 1055, 527, 0, 3340, 478, 1, 0, 0, 0, 3341, 3342, 3, 1021, 510, 0, 3342, 3343, 3, 1017, 508, 0, 3343, 3344, 3, 1043, 521, 0, 3344, 3345, 3, 1021, 510, 0, 3345, 3346, 3, 1025, 512, 0, 3346, 3347, 3, 1039, 519, 0, 3347, 480, 1, 0, 0, 0, 3348, 3349, 3, 1047, 523, 0, 3349, 3350, 3, 1051, 525, 0, 3350, 3351, 3, 1033, 516, 0, 3351, 3352, 3, 1041, 520, 0, 3352, 3353, 3, 1017, 508, 0, 3353, 3354, 3, 1051, 525, 0, 3354, 3355, 3, 1065, 532, 0, 3355, 482, 1, 0, 0, 0, 3356, 3357, 3, 1053, 526, 0, 3357, 3358, 3, 1057, 528, 0, 3358, 3359, 3, 1021, 510, 0, 3359, 3360, 3, 1021, 510, 0, 3360, 3361, 3, 1025, 512, 0, 3361, 3362, 3, 1053, 526, 0, 3362, 3363, 3, 1053, 526, 0, 3363, 484, 1, 0, 0, 0, 3364, 3365, 3, 1023, 511, 0, 3365, 3366, 3, 1017, 508, 0, 3366, 3367, 3, 1043, 521, 0, 3367, 3368, 3, 1029, 514, 0, 3368, 3369, 3, 1025, 512, 0, 3369, 3370, 3, 1051, 525, 0, 3370, 486, 1, 0, 0, 0, 3371, 3372, 3, 1061, 530, 0, 3372, 3373, 3, 1017, 508, 0, 3373, 3374, 3, 1051, 525, 0, 3374, 3375, 3, 1043, 521, 0, 3375, 3376, 3, 1033, 516, 0, 3376, 3377, 3, 1043, 521, 0, 3377, 3378, 3, 1029, 514, 0, 3378, 488, 1, 0, 0, 0, 3379, 3380, 3, 1033, 516, 0, 3380, 3381, 3, 1043, 521, 0, 3381, 3382, 3, 1027, 513, 0, 3382, 3383, 3, 1045, 522, 0, 3383, 490, 1, 0, 0, 0, 3384, 3385, 3, 1055, 527, 0, 3385, 3386, 3, 1025, 512, 0, 3386, 3387, 3, 1041, 520, 0, 3387, 3388, 3, 1047, 523, 0, 3388, 3389, 3, 1039, 519, 0, 3389, 3390, 3, 1017, 508, 0, 3390, 3391, 3, 1055, 527, 0, 3391, 3392, 3, 1025, 512, 0, 3392, 492, 1, 0, 0, 0, 3393, 3394, 3, 1045, 522, 0, 3394, 3395, 3, 1043, 521, 0, 3395, 3396, 3, 1021, 510, 0, 3396, 3397, 3, 1039, 519, 0, 3397, 3398, 3, 1033, 516, 0, 3398, 3399, 3, 1021, 510, 0, 3399, 3400, 3, 1037, 518, 0, 3400, 494, 1, 0, 0, 0, 3401, 3402, 3, 1045, 522, 0, 3402, 3403, 3, 1043, 521, 0, 3403, 3404, 3, 1021, 510, 0, 3404, 3405, 3, 1031, 515, 0, 3405, 3406, 3, 1017, 508, 0, 3406, 3407, 3, 1043, 521, 0, 3407, 3408, 3, 1029, 514, 0, 3408, 3409, 3, 1025, 512, 0, 3409, 496, 1, 0, 0, 0, 3410, 3411, 3, 1055, 527, 0, 3411, 3412, 3, 1017, 508, 0, 3412, 3413, 3, 1019, 509, 0, 3413, 3414, 3, 1033, 516, 0, 3414, 3415, 3, 1043, 521, 0, 3415, 3416, 3, 1023, 511, 0, 3416, 3417, 3, 1025, 512, 0, 3417, 3418, 3, 1063, 531, 0, 3418, 498, 1, 0, 0, 0, 3419, 3420, 3, 1031, 515, 0, 3420, 3421, 5, 49, 0, 0, 3421, 500, 1, 0, 0, 0, 3422, 3423, 3, 1031, 515, 0, 3423, 3424, 5, 50, 0, 0, 3424, 502, 1, 0, 0, 0, 3425, 3426, 3, 1031, 515, 0, 3426, 3427, 5, 51, 0, 0, 3427, 504, 1, 0, 0, 0, 3428, 3429, 3, 1031, 515, 0, 3429, 3430, 5, 52, 0, 0, 3430, 506, 1, 0, 0, 0, 3431, 3432, 3, 1031, 515, 0, 3432, 3433, 5, 53, 0, 0, 3433, 508, 1, 0, 0, 0, 3434, 3435, 3, 1031, 515, 0, 3435, 3436, 5, 54, 0, 0, 3436, 510, 1, 0, 0, 0, 3437, 3438, 3, 1047, 523, 0, 3438, 3439, 3, 1017, 508, 0, 3439, 3440, 3, 1051, 525, 0, 3440, 3441, 3, 1017, 508, 0, 3441, 3442, 3, 1029, 514, 0, 3442, 3443, 3, 1051, 525, 0, 3443, 3444, 3, 1017, 508, 0, 3444, 3445, 3, 1047, 523, 0, 3445, 3446, 3, 1031, 515, 0, 3446, 512, 1, 0, 0, 0, 3447, 3448, 3, 1053, 526, 0, 3448, 3449, 3, 1055, 527, 0, 3449, 3450, 3, 1051, 525, 0, 3450, 3451, 3, 1033, 516, 0, 3451, 3452, 3, 1043, 521, 0, 3452, 3453, 3, 1029, 514, 0, 3453, 514, 1, 0, 0, 0, 3454, 3455, 3, 1033, 516, 0, 3455, 3456, 3, 1043, 521, 0, 3456, 3457, 3, 1055, 527, 0, 3457, 3458, 3, 1025, 512, 0, 3458, 3459, 3, 1029, 514, 0, 3459, 3460, 3, 1025, 512, 0, 3460, 3461, 3, 1051, 525, 0, 3461, 516, 1, 0, 0, 0, 3462, 3463, 3, 1039, 519, 0, 3463, 3464, 3, 1045, 522, 0, 3464, 3465, 3, 1043, 521, 0, 3465, 3466, 3, 1029, 514, 0, 3466, 518, 1, 0, 0, 0, 3467, 3468, 3, 1023, 511, 0, 3468, 3469, 3, 1025, 512, 0, 3469, 3470, 3, 1021, 510, 0, 3470, 3471, 3, 1033, 516, 0, 3471, 3472, 3, 1041, 520, 0, 3472, 3473, 3, 1017, 508, 0, 3473, 3474, 3, 1039, 519, 0, 3474, 520, 1, 0, 0, 0, 3475, 3476, 3, 1019, 509, 0, 3476, 3477, 3, 1045, 522, 0, 3477, 3478, 3, 1045, 522, 0, 3478, 3479, 3, 1039, 519, 0, 3479, 3480, 3, 1025, 512, 0, 3480, 3481, 3, 1017, 508, 0, 3481, 3482, 3, 1043, 521, 0, 3482, 522, 1, 0, 0, 0, 3483, 3484, 3, 1023, 511, 0, 3484, 3485, 3, 1017, 508, 0, 3485, 3486, 3, 1055, 527, 0, 3486, 3487, 3, 1025, 512, 0, 3487, 3488, 3, 1055, 527, 0, 3488, 3489, 3, 1033, 516, 0, 3489, 3490, 3, 1041, 520, 0, 3490, 3491, 3, 1025, 512, 0, 3491, 524, 1, 0, 0, 0, 3492, 3493, 3, 1023, 511, 0, 3493, 3494, 3, 1017, 508, 0, 3494, 3495, 3, 1055, 527, 0, 3495, 3496, 3, 1025, 512, 0, 3496, 526, 1, 0, 0, 0, 3497, 3498, 3, 1017, 508, 0, 3498, 3499, 3, 1057, 528, 0, 3499, 3500, 3, 1055, 527, 0, 3500, 3501, 3, 1045, 522, 0, 3501, 3502, 3, 1043, 521, 0, 3502, 3503, 3, 1057, 528, 0, 3503, 3504, 3, 1041, 520, 0, 3504, 3505, 3, 1019, 509, 0, 3505, 3506, 3, 1025, 512, 0, 3506, 3507, 3, 1051, 525, 0, 3507, 528, 1, 0, 0, 0, 3508, 3509, 3, 1019, 509, 0, 3509, 3510, 3, 1033, 516, 0, 3510, 3511, 3, 1043, 521, 0, 3511, 3512, 3, 1017, 508, 0, 3512, 3513, 3, 1051, 525, 0, 3513, 3514, 3, 1065, 532, 0, 3514, 530, 1, 0, 0, 0, 3515, 3516, 3, 1031, 515, 0, 3516, 3517, 3, 1017, 508, 0, 3517, 3518, 3, 1053, 526, 0, 3518, 3519, 3, 1031, 515, 0, 3519, 3520, 3, 1025, 512, 0, 3520, 3521, 3, 1023, 511, 0, 3521, 3522, 3, 1053, 526, 0, 3522, 3523, 3, 1055, 527, 0, 3523, 3524, 3, 1051, 525, 0, 3524, 3525, 3, 1033, 516, 0, 3525, 3526, 3, 1043, 521, 0, 3526, 3527, 3, 1029, 514, 0, 3527, 532, 1, 0, 0, 0, 3528, 3529, 3, 1021, 510, 0, 3529, 3530, 3, 1057, 528, 0, 3530, 3531, 3, 1051, 525, 0, 3531, 3532, 3, 1051, 525, 0, 3532, 3533, 3, 1025, 512, 0, 3533, 3534, 3, 1043, 521, 0, 3534, 3535, 3, 1021, 510, 0, 3535, 3536, 3, 1065, 532, 0, 3536, 534, 1, 0, 0, 0, 3537, 3538, 3, 1027, 513, 0, 3538, 3539, 3, 1039, 519, 0, 3539, 3540, 3, 1045, 522, 0, 3540, 3541, 3, 1017, 508, 0, 3541, 3542, 3, 1055, 527, 0, 3542, 536, 1, 0, 0, 0, 3543, 3544, 3, 1053, 526, 0, 3544, 3545, 3, 1055, 527, 0, 3545, 3546, 3, 1051, 525, 0, 3546, 3547, 3, 1033, 516, 0, 3547, 3548, 3, 1043, 521, 0, 3548, 3549, 3, 1029, 514, 0, 3549, 3550, 3, 1055, 527, 0, 3550, 3551, 3, 1025, 512, 0, 3551, 3552, 3, 1041, 520, 0, 3552, 3553, 3, 1047, 523, 0, 3553, 3554, 3, 1039, 519, 0, 3554, 3555, 3, 1017, 508, 0, 3555, 3556, 3, 1055, 527, 0, 3556, 3557, 3, 1025, 512, 0, 3557, 538, 1, 0, 0, 0, 3558, 3559, 3, 1025, 512, 0, 3559, 3560, 3, 1043, 521, 0, 3560, 3561, 3, 1057, 528, 0, 3561, 3562, 3, 1041, 520, 0, 3562, 540, 1, 0, 0, 0, 3563, 3564, 3, 1021, 510, 0, 3564, 3565, 3, 1045, 522, 0, 3565, 3566, 3, 1057, 528, 0, 3566, 3567, 3, 1043, 521, 0, 3567, 3568, 3, 1055, 527, 0, 3568, 542, 1, 0, 0, 0, 3569, 3570, 3, 1053, 526, 0, 3570, 3571, 3, 1057, 528, 0, 3571, 3572, 3, 1041, 520, 0, 3572, 544, 1, 0, 0, 0, 3573, 3574, 3, 1017, 508, 0, 3574, 3575, 3, 1059, 529, 0, 3575, 3576, 3, 1029, 514, 0, 3576, 546, 1, 0, 0, 0, 3577, 3578, 3, 1041, 520, 0, 3578, 3579, 3, 1033, 516, 0, 3579, 3580, 3, 1043, 521, 0, 3580, 548, 1, 0, 0, 0, 3581, 3582, 3, 1041, 520, 0, 3582, 3583, 3, 1017, 508, 0, 3583, 3584, 3, 1063, 531, 0, 3584, 550, 1, 0, 0, 0, 3585, 3586, 3, 1039, 519, 0, 3586, 3587, 3, 1025, 512, 0, 3587, 3588, 3, 1043, 521, 0, 3588, 3589, 3, 1029, 514, 0, 3589, 3590, 3, 1055, 527, 0, 3590, 3591, 3, 1031, 515, 0, 3591, 552, 1, 0, 0, 0, 3592, 3593, 3, 1055, 527, 0, 3593, 3594, 3, 1051, 525, 0, 3594, 3595, 3, 1033, 516, 0, 3595, 3596, 3, 1041, 520, 0, 3596, 554, 1, 0, 0, 0, 3597, 3598, 3, 1021, 510, 0, 3598, 3599, 3, 1045, 522, 0, 3599, 3600, 3, 1017, 508, 0, 3600, 3601, 3, 1039, 519, 0, 3601, 3602, 3, 1025, 512, 0, 3602, 3603, 3, 1053, 526, 0, 3603, 3604, 3, 1021, 510, 0, 3604, 3605, 3, 1025, 512, 0, 3605, 556, 1, 0, 0, 0, 3606, 3607, 3, 1021, 510, 0, 3607, 3608, 3, 1017, 508, 0, 3608, 3609, 3, 1053, 526, 0, 3609, 3610, 3, 1055, 527, 0, 3610, 558, 1, 0, 0, 0, 3611, 3612, 3, 1017, 508, 0, 3612, 3613, 3, 1043, 521, 0, 3613, 3614, 3, 1023, 511, 0, 3614, 560, 1, 0, 0, 0, 3615, 3616, 3, 1045, 522, 0, 3616, 3617, 3, 1051, 525, 0, 3617, 562, 1, 0, 0, 0, 3618, 3619, 3, 1043, 521, 0, 3619, 3620, 3, 1045, 522, 0, 3620, 3621, 3, 1055, 527, 0, 3621, 564, 1, 0, 0, 0, 3622, 3623, 3, 1043, 521, 0, 3623, 3624, 3, 1057, 528, 0, 3624, 3625, 3, 1039, 519, 0, 3625, 3626, 3, 1039, 519, 0, 3626, 566, 1, 0, 0, 0, 3627, 3628, 3, 1033, 516, 0, 3628, 3629, 3, 1043, 521, 0, 3629, 568, 1, 0, 0, 0, 3630, 3631, 3, 1019, 509, 0, 3631, 3632, 3, 1025, 512, 0, 3632, 3633, 3, 1055, 527, 0, 3633, 3634, 3, 1061, 530, 0, 3634, 3635, 3, 1025, 512, 0, 3635, 3636, 3, 1025, 512, 0, 3636, 3637, 3, 1043, 521, 0, 3637, 570, 1, 0, 0, 0, 3638, 3639, 3, 1039, 519, 0, 3639, 3640, 3, 1033, 516, 0, 3640, 3641, 3, 1037, 518, 0, 3641, 3642, 3, 1025, 512, 0, 3642, 572, 1, 0, 0, 0, 3643, 3644, 3, 1041, 520, 0, 3644, 3645, 3, 1017, 508, 0, 3645, 3646, 3, 1055, 527, 0, 3646, 3647, 3, 1021, 510, 0, 3647, 3648, 3, 1031, 515, 0, 3648, 574, 1, 0, 0, 0, 3649, 3650, 3, 1025, 512, 0, 3650, 3651, 3, 1063, 531, 0, 3651, 3652, 3, 1033, 516, 0, 3652, 3653, 3, 1053, 526, 0, 3653, 3654, 3, 1055, 527, 0, 3654, 3655, 3, 1053, 526, 0, 3655, 576, 1, 0, 0, 0, 3656, 3657, 3, 1057, 528, 0, 3657, 3658, 3, 1043, 521, 0, 3658, 3659, 3, 1033, 516, 0, 3659, 3660, 3, 1049, 524, 0, 3660, 3661, 3, 1057, 528, 0, 3661, 3662, 3, 1025, 512, 0, 3662, 578, 1, 0, 0, 0, 3663, 3664, 3, 1023, 511, 0, 3664, 3665, 3, 1025, 512, 0, 3665, 3666, 3, 1027, 513, 0, 3666, 3667, 3, 1017, 508, 0, 3667, 3668, 3, 1057, 528, 0, 3668, 3669, 3, 1039, 519, 0, 3669, 3670, 3, 1055, 527, 0, 3670, 580, 1, 0, 0, 0, 3671, 3672, 3, 1055, 527, 0, 3672, 3673, 3, 1051, 525, 0, 3673, 3674, 3, 1057, 528, 0, 3674, 3675, 3, 1025, 512, 0, 3675, 582, 1, 0, 0, 0, 3676, 3677, 3, 1027, 513, 0, 3677, 3678, 3, 1017, 508, 0, 3678, 3679, 3, 1039, 519, 0, 3679, 3680, 3, 1053, 526, 0, 3680, 3681, 3, 1025, 512, 0, 3681, 584, 1, 0, 0, 0, 3682, 3683, 3, 1059, 529, 0, 3683, 3684, 3, 1017, 508, 0, 3684, 3685, 3, 1039, 519, 0, 3685, 3686, 3, 1033, 516, 0, 3686, 3687, 3, 1023, 511, 0, 3687, 3688, 3, 1017, 508, 0, 3688, 3689, 3, 1055, 527, 0, 3689, 3690, 3, 1033, 516, 0, 3690, 3691, 3, 1045, 522, 0, 3691, 3692, 3, 1043, 521, 0, 3692, 586, 1, 0, 0, 0, 3693, 3694, 3, 1027, 513, 0, 3694, 3695, 3, 1025, 512, 0, 3695, 3696, 3, 1025, 512, 0, 3696, 3697, 3, 1023, 511, 0, 3697, 3698, 3, 1019, 509, 0, 3698, 3699, 3, 1017, 508, 0, 3699, 3700, 3, 1021, 510, 0, 3700, 3701, 3, 1037, 518, 0, 3701, 588, 1, 0, 0, 0, 3702, 3703, 3, 1051, 525, 0, 3703, 3704, 3, 1057, 528, 0, 3704, 3705, 3, 1039, 519, 0, 3705, 3706, 3, 1025, 512, 0, 3706, 590, 1, 0, 0, 0, 3707, 3708, 3, 1051, 525, 0, 3708, 3709, 3, 1025, 512, 0, 3709, 3710, 3, 1049, 524, 0, 3710, 3711, 3, 1057, 528, 0, 3711, 3712, 3, 1033, 516, 0, 3712, 3713, 3, 1051, 525, 0, 3713, 3714, 3, 1025, 512, 0, 3714, 3715, 3, 1023, 511, 0, 3715, 592, 1, 0, 0, 0, 3716, 3717, 3, 1025, 512, 0, 3717, 3718, 3, 1051, 525, 0, 3718, 3719, 3, 1051, 525, 0, 3719, 3720, 3, 1045, 522, 0, 3720, 3721, 3, 1051, 525, 0, 3721, 594, 1, 0, 0, 0, 3722, 3723, 3, 1051, 525, 0, 3723, 3724, 3, 1017, 508, 0, 3724, 3725, 3, 1033, 516, 0, 3725, 3726, 3, 1053, 526, 0, 3726, 3727, 3, 1025, 512, 0, 3727, 596, 1, 0, 0, 0, 3728, 3729, 3, 1051, 525, 0, 3729, 3730, 3, 1017, 508, 0, 3730, 3731, 3, 1043, 521, 0, 3731, 3732, 3, 1029, 514, 0, 3732, 3733, 3, 1025, 512, 0, 3733, 598, 1, 0, 0, 0, 3734, 3735, 3, 1051, 525, 0, 3735, 3736, 3, 1025, 512, 0, 3736, 3737, 3, 1029, 514, 0, 3737, 3738, 3, 1025, 512, 0, 3738, 3739, 3, 1063, 531, 0, 3739, 600, 1, 0, 0, 0, 3740, 3741, 3, 1047, 523, 0, 3741, 3742, 3, 1017, 508, 0, 3742, 3743, 3, 1055, 527, 0, 3743, 3744, 3, 1055, 527, 0, 3744, 3745, 3, 1025, 512, 0, 3745, 3746, 3, 1051, 525, 0, 3746, 3747, 3, 1043, 521, 0, 3747, 602, 1, 0, 0, 0, 3748, 3749, 3, 1025, 512, 0, 3749, 3750, 3, 1063, 531, 0, 3750, 3751, 3, 1047, 523, 0, 3751, 3752, 3, 1051, 525, 0, 3752, 3753, 3, 1025, 512, 0, 3753, 3754, 3, 1053, 526, 0, 3754, 3755, 3, 1053, 526, 0, 3755, 3756, 3, 1033, 516, 0, 3756, 3757, 3, 1045, 522, 0, 3757, 3758, 3, 1043, 521, 0, 3758, 604, 1, 0, 0, 0, 3759, 3760, 3, 1063, 531, 0, 3760, 3761, 3, 1047, 523, 0, 3761, 3762, 3, 1017, 508, 0, 3762, 3763, 3, 1055, 527, 0, 3763, 3764, 3, 1031, 515, 0, 3764, 606, 1, 0, 0, 0, 3765, 3766, 3, 1021, 510, 0, 3766, 3767, 3, 1045, 522, 0, 3767, 3768, 3, 1043, 521, 0, 3768, 3769, 3, 1053, 526, 0, 3769, 3770, 3, 1055, 527, 0, 3770, 3771, 3, 1051, 525, 0, 3771, 3772, 3, 1017, 508, 0, 3772, 3773, 3, 1033, 516, 0, 3773, 3774, 3, 1043, 521, 0, 3774, 3775, 3, 1055, 527, 0, 3775, 608, 1, 0, 0, 0, 3776, 3777, 3, 1021, 510, 0, 3777, 3778, 3, 1017, 508, 0, 3778, 3779, 3, 1039, 519, 0, 3779, 3780, 3, 1021, 510, 0, 3780, 3781, 3, 1057, 528, 0, 3781, 3782, 3, 1039, 519, 0, 3782, 3783, 3, 1017, 508, 0, 3783, 3784, 3, 1055, 527, 0, 3784, 3785, 3, 1025, 512, 0, 3785, 3786, 3, 1023, 511, 0, 3786, 610, 1, 0, 0, 0, 3787, 3788, 3, 1051, 525, 0, 3788, 3789, 3, 1025, 512, 0, 3789, 3790, 3, 1053, 526, 0, 3790, 3791, 3, 1055, 527, 0, 3791, 612, 1, 0, 0, 0, 3792, 3793, 3, 1053, 526, 0, 3793, 3794, 3, 1025, 512, 0, 3794, 3795, 3, 1051, 525, 0, 3795, 3796, 3, 1059, 529, 0, 3796, 3797, 3, 1033, 516, 0, 3797, 3798, 3, 1021, 510, 0, 3798, 3799, 3, 1025, 512, 0, 3799, 614, 1, 0, 0, 0, 3800, 3801, 3, 1053, 526, 0, 3801, 3802, 3, 1025, 512, 0, 3802, 3803, 3, 1051, 525, 0, 3803, 3804, 3, 1059, 529, 0, 3804, 3805, 3, 1033, 516, 0, 3805, 3806, 3, 1021, 510, 0, 3806, 3807, 3, 1025, 512, 0, 3807, 3808, 3, 1053, 526, 0, 3808, 616, 1, 0, 0, 0, 3809, 3810, 3, 1045, 522, 0, 3810, 3811, 3, 1023, 511, 0, 3811, 3812, 3, 1017, 508, 0, 3812, 3813, 3, 1055, 527, 0, 3813, 3814, 3, 1017, 508, 0, 3814, 618, 1, 0, 0, 0, 3815, 3816, 3, 1019, 509, 0, 3816, 3817, 3, 1017, 508, 0, 3817, 3818, 3, 1053, 526, 0, 3818, 3819, 3, 1025, 512, 0, 3819, 620, 1, 0, 0, 0, 3820, 3821, 3, 1017, 508, 0, 3821, 3822, 3, 1057, 528, 0, 3822, 3823, 3, 1055, 527, 0, 3823, 3824, 3, 1031, 515, 0, 3824, 622, 1, 0, 0, 0, 3825, 3826, 3, 1017, 508, 0, 3826, 3827, 3, 1057, 528, 0, 3827, 3828, 3, 1055, 527, 0, 3828, 3829, 3, 1031, 515, 0, 3829, 3830, 3, 1025, 512, 0, 3830, 3831, 3, 1043, 521, 0, 3831, 3832, 3, 1055, 527, 0, 3832, 3833, 3, 1033, 516, 0, 3833, 3834, 3, 1021, 510, 0, 3834, 3835, 3, 1017, 508, 0, 3835, 3836, 3, 1055, 527, 0, 3836, 3837, 3, 1033, 516, 0, 3837, 3838, 3, 1045, 522, 0, 3838, 3839, 3, 1043, 521, 0, 3839, 624, 1, 0, 0, 0, 3840, 3841, 3, 1019, 509, 0, 3841, 3842, 3, 1017, 508, 0, 3842, 3843, 3, 1053, 526, 0, 3843, 3844, 3, 1033, 516, 0, 3844, 3845, 3, 1021, 510, 0, 3845, 626, 1, 0, 0, 0, 3846, 3847, 3, 1043, 521, 0, 3847, 3848, 3, 1045, 522, 0, 3848, 3849, 3, 1055, 527, 0, 3849, 3850, 3, 1031, 515, 0, 3850, 3851, 3, 1033, 516, 0, 3851, 3852, 3, 1043, 521, 0, 3852, 3853, 3, 1029, 514, 0, 3853, 628, 1, 0, 0, 0, 3854, 3855, 3, 1045, 522, 0, 3855, 3856, 3, 1017, 508, 0, 3856, 3857, 3, 1057, 528, 0, 3857, 3858, 3, 1055, 527, 0, 3858, 3859, 3, 1031, 515, 0, 3859, 630, 1, 0, 0, 0, 3860, 3861, 3, 1045, 522, 0, 3861, 3862, 3, 1047, 523, 0, 3862, 3863, 3, 1025, 512, 0, 3863, 3864, 3, 1051, 525, 0, 3864, 3865, 3, 1017, 508, 0, 3865, 3866, 3, 1055, 527, 0, 3866, 3867, 3, 1033, 516, 0, 3867, 3868, 3, 1045, 522, 0, 3868, 3869, 3, 1043, 521, 0, 3869, 632, 1, 0, 0, 0, 3870, 3871, 3, 1041, 520, 0, 3871, 3872, 3, 1025, 512, 0, 3872, 3873, 3, 1055, 527, 0, 3873, 3874, 3, 1031, 515, 0, 3874, 3875, 3, 1045, 522, 0, 3875, 3876, 3, 1023, 511, 0, 3876, 634, 1, 0, 0, 0, 3877, 3878, 3, 1047, 523, 0, 3878, 3879, 3, 1017, 508, 0, 3879, 3880, 3, 1055, 527, 0, 3880, 3881, 3, 1031, 515, 0, 3881, 636, 1, 0, 0, 0, 3882, 3883, 3, 1055, 527, 0, 3883, 3884, 3, 1033, 516, 0, 3884, 3885, 3, 1041, 520, 0, 3885, 3886, 3, 1025, 512, 0, 3886, 3887, 3, 1045, 522, 0, 3887, 3888, 3, 1057, 528, 0, 3888, 3889, 3, 1055, 527, 0, 3889, 638, 1, 0, 0, 0, 3890, 3891, 3, 1019, 509, 0, 3891, 3892, 3, 1045, 522, 0, 3892, 3893, 3, 1023, 511, 0, 3893, 3894, 3, 1065, 532, 0, 3894, 640, 1, 0, 0, 0, 3895, 3896, 3, 1051, 525, 0, 3896, 3897, 3, 1025, 512, 0, 3897, 3898, 3, 1053, 526, 0, 3898, 3899, 3, 1047, 523, 0, 3899, 3900, 3, 1045, 522, 0, 3900, 3901, 3, 1043, 521, 0, 3901, 3902, 3, 1053, 526, 0, 3902, 3903, 3, 1025, 512, 0, 3903, 642, 1, 0, 0, 0, 3904, 3905, 3, 1051, 525, 0, 3905, 3906, 3, 1025, 512, 0, 3906, 3907, 3, 1049, 524, 0, 3907, 3908, 3, 1057, 528, 0, 3908, 3909, 3, 1025, 512, 0, 3909, 3910, 3, 1053, 526, 0, 3910, 3911, 3, 1055, 527, 0, 3911, 644, 1, 0, 0, 0, 3912, 3913, 3, 1035, 517, 0, 3913, 3914, 3, 1053, 526, 0, 3914, 3915, 3, 1045, 522, 0, 3915, 3916, 3, 1043, 521, 0, 3916, 646, 1, 0, 0, 0, 3917, 3918, 3, 1063, 531, 0, 3918, 3919, 3, 1041, 520, 0, 3919, 3920, 3, 1039, 519, 0, 3920, 648, 1, 0, 0, 0, 3921, 3922, 3, 1053, 526, 0, 3922, 3923, 3, 1055, 527, 0, 3923, 3924, 3, 1017, 508, 0, 3924, 3925, 3, 1055, 527, 0, 3925, 3926, 3, 1057, 528, 0, 3926, 3927, 3, 1053, 526, 0, 3927, 650, 1, 0, 0, 0, 3928, 3929, 3, 1059, 529, 0, 3929, 3930, 3, 1025, 512, 0, 3930, 3931, 3, 1051, 525, 0, 3931, 3932, 3, 1053, 526, 0, 3932, 3933, 3, 1033, 516, 0, 3933, 3934, 3, 1045, 522, 0, 3934, 3935, 3, 1043, 521, 0, 3935, 652, 1, 0, 0, 0, 3936, 3937, 3, 1029, 514, 0, 3937, 3938, 3, 1025, 512, 0, 3938, 3939, 3, 1055, 527, 0, 3939, 654, 1, 0, 0, 0, 3940, 3941, 3, 1047, 523, 0, 3941, 3942, 3, 1045, 522, 0, 3942, 3943, 3, 1053, 526, 0, 3943, 3944, 3, 1055, 527, 0, 3944, 656, 1, 0, 0, 0, 3945, 3946, 3, 1047, 523, 0, 3946, 3947, 3, 1057, 528, 0, 3947, 3948, 3, 1055, 527, 0, 3948, 658, 1, 0, 0, 0, 3949, 3950, 3, 1047, 523, 0, 3950, 3951, 3, 1017, 508, 0, 3951, 3952, 3, 1055, 527, 0, 3952, 3953, 3, 1021, 510, 0, 3953, 3954, 3, 1031, 515, 0, 3954, 660, 1, 0, 0, 0, 3955, 3956, 3, 1017, 508, 0, 3956, 3957, 3, 1047, 523, 0, 3957, 3958, 3, 1033, 516, 0, 3958, 662, 1, 0, 0, 0, 3959, 3960, 3, 1021, 510, 0, 3960, 3961, 3, 1039, 519, 0, 3961, 3962, 3, 1033, 516, 0, 3962, 3963, 3, 1025, 512, 0, 3963, 3964, 3, 1043, 521, 0, 3964, 3965, 3, 1055, 527, 0, 3965, 664, 1, 0, 0, 0, 3966, 3967, 3, 1021, 510, 0, 3967, 3968, 3, 1039, 519, 0, 3968, 3969, 3, 1033, 516, 0, 3969, 3970, 3, 1025, 512, 0, 3970, 3971, 3, 1043, 521, 0, 3971, 3972, 3, 1055, 527, 0, 3972, 3973, 3, 1053, 526, 0, 3973, 666, 1, 0, 0, 0, 3974, 3975, 3, 1047, 523, 0, 3975, 3976, 3, 1057, 528, 0, 3976, 3977, 3, 1019, 509, 0, 3977, 3978, 3, 1039, 519, 0, 3978, 3979, 3, 1033, 516, 0, 3979, 3980, 3, 1053, 526, 0, 3980, 3981, 3, 1031, 515, 0, 3981, 668, 1, 0, 0, 0, 3982, 3983, 3, 1025, 512, 0, 3983, 3984, 3, 1063, 531, 0, 3984, 3985, 3, 1047, 523, 0, 3985, 3986, 3, 1045, 522, 0, 3986, 3987, 3, 1053, 526, 0, 3987, 3988, 3, 1025, 512, 0, 3988, 670, 1, 0, 0, 0, 3989, 3990, 3, 1043, 521, 0, 3990, 3991, 3, 1017, 508, 0, 3991, 3992, 3, 1041, 520, 0, 3992, 3993, 3, 1025, 512, 0, 3993, 3994, 3, 1053, 526, 0, 3994, 3995, 3, 1047, 523, 0, 3995, 3996, 3, 1017, 508, 0, 3996, 3997, 3, 1021, 510, 0, 3997, 3998, 3, 1025, 512, 0, 3998, 672, 1, 0, 0, 0, 3999, 4000, 3, 1053, 526, 0, 4000, 4001, 3, 1025, 512, 0, 4001, 4002, 3, 1053, 526, 0, 4002, 4003, 3, 1053, 526, 0, 4003, 4004, 3, 1033, 516, 0, 4004, 4005, 3, 1045, 522, 0, 4005, 4006, 3, 1043, 521, 0, 4006, 674, 1, 0, 0, 0, 4007, 4008, 3, 1029, 514, 0, 4008, 4009, 3, 1057, 528, 0, 4009, 4010, 3, 1025, 512, 0, 4010, 4011, 3, 1053, 526, 0, 4011, 4012, 3, 1055, 527, 0, 4012, 676, 1, 0, 0, 0, 4013, 4014, 3, 1047, 523, 0, 4014, 4015, 3, 1017, 508, 0, 4015, 4016, 3, 1029, 514, 0, 4016, 4017, 3, 1033, 516, 0, 4017, 4018, 3, 1043, 521, 0, 4018, 4019, 3, 1029, 514, 0, 4019, 678, 1, 0, 0, 0, 4020, 4021, 3, 1043, 521, 0, 4021, 4022, 3, 1045, 522, 0, 4022, 4023, 3, 1055, 527, 0, 4023, 4024, 5, 95, 0, 0, 4024, 4025, 3, 1053, 526, 0, 4025, 4026, 3, 1057, 528, 0, 4026, 4027, 3, 1047, 523, 0, 4027, 4028, 3, 1047, 523, 0, 4028, 4029, 3, 1045, 522, 0, 4029, 4030, 3, 1051, 525, 0, 4030, 4031, 3, 1055, 527, 0, 4031, 4032, 3, 1025, 512, 0, 4032, 4033, 3, 1023, 511, 0, 4033, 680, 1, 0, 0, 0, 4034, 4035, 3, 1057, 528, 0, 4035, 4036, 3, 1053, 526, 0, 4036, 4037, 3, 1025, 512, 0, 4037, 4038, 3, 1051, 525, 0, 4038, 4039, 3, 1043, 521, 0, 4039, 4040, 3, 1017, 508, 0, 4040, 4041, 3, 1041, 520, 0, 4041, 4042, 3, 1025, 512, 0, 4042, 682, 1, 0, 0, 0, 4043, 4044, 3, 1047, 523, 0, 4044, 4045, 3, 1017, 508, 0, 4045, 4046, 3, 1053, 526, 0, 4046, 4047, 3, 1053, 526, 0, 4047, 4048, 3, 1061, 530, 0, 4048, 4049, 3, 1045, 522, 0, 4049, 4050, 3, 1051, 525, 0, 4050, 4051, 3, 1023, 511, 0, 4051, 684, 1, 0, 0, 0, 4052, 4053, 3, 1021, 510, 0, 4053, 4054, 3, 1045, 522, 0, 4054, 4055, 3, 1043, 521, 0, 4055, 4056, 3, 1043, 521, 0, 4056, 4057, 3, 1025, 512, 0, 4057, 4058, 3, 1021, 510, 0, 4058, 4059, 3, 1055, 527, 0, 4059, 4060, 3, 1033, 516, 0, 4060, 4061, 3, 1045, 522, 0, 4061, 4062, 3, 1043, 521, 0, 4062, 686, 1, 0, 0, 0, 4063, 4064, 3, 1023, 511, 0, 4064, 4065, 3, 1017, 508, 0, 4065, 4066, 3, 1055, 527, 0, 4066, 4067, 3, 1017, 508, 0, 4067, 4068, 3, 1019, 509, 0, 4068, 4069, 3, 1017, 508, 0, 4069, 4070, 3, 1053, 526, 0, 4070, 4071, 3, 1025, 512, 0, 4071, 688, 1, 0, 0, 0, 4072, 4073, 3, 1049, 524, 0, 4073, 4074, 3, 1057, 528, 0, 4074, 4075, 3, 1025, 512, 0, 4075, 4076, 3, 1051, 525, 0, 4076, 4077, 3, 1065, 532, 0, 4077, 690, 1, 0, 0, 0, 4078, 4079, 3, 1041, 520, 0, 4079, 4080, 3, 1017, 508, 0, 4080, 4081, 3, 1047, 523, 0, 4081, 692, 1, 0, 0, 0, 4082, 4083, 3, 1041, 520, 0, 4083, 4084, 3, 1017, 508, 0, 4084, 4085, 3, 1047, 523, 0, 4085, 4086, 3, 1047, 523, 0, 4086, 4087, 3, 1033, 516, 0, 4087, 4088, 3, 1043, 521, 0, 4088, 4089, 3, 1029, 514, 0, 4089, 694, 1, 0, 0, 0, 4090, 4091, 3, 1033, 516, 0, 4091, 4092, 3, 1041, 520, 0, 4092, 4093, 3, 1047, 523, 0, 4093, 4094, 3, 1045, 522, 0, 4094, 4095, 3, 1051, 525, 0, 4095, 4096, 3, 1055, 527, 0, 4096, 696, 1, 0, 0, 0, 4097, 4098, 3, 1033, 516, 0, 4098, 4099, 3, 1043, 521, 0, 4099, 4100, 3, 1055, 527, 0, 4100, 4101, 3, 1045, 522, 0, 4101, 698, 1, 0, 0, 0, 4102, 4103, 3, 1019, 509, 0, 4103, 4104, 3, 1017, 508, 0, 4104, 4105, 3, 1055, 527, 0, 4105, 4106, 3, 1021, 510, 0, 4106, 4107, 3, 1031, 515, 0, 4107, 700, 1, 0, 0, 0, 4108, 4109, 3, 1039, 519, 0, 4109, 4110, 3, 1033, 516, 0, 4110, 4111, 3, 1043, 521, 0, 4111, 4112, 3, 1037, 518, 0, 4112, 702, 1, 0, 0, 0, 4113, 4114, 3, 1025, 512, 0, 4114, 4115, 3, 1063, 531, 0, 4115, 4116, 3, 1047, 523, 0, 4116, 4117, 3, 1045, 522, 0, 4117, 4118, 3, 1051, 525, 0, 4118, 4119, 3, 1055, 527, 0, 4119, 704, 1, 0, 0, 0, 4120, 4121, 3, 1029, 514, 0, 4121, 4122, 3, 1025, 512, 0, 4122, 4123, 3, 1043, 521, 0, 4123, 4124, 3, 1025, 512, 0, 4124, 4125, 3, 1051, 525, 0, 4125, 4126, 3, 1017, 508, 0, 4126, 4127, 3, 1055, 527, 0, 4127, 4128, 3, 1025, 512, 0, 4128, 706, 1, 0, 0, 0, 4129, 4130, 3, 1021, 510, 0, 4130, 4131, 3, 1045, 522, 0, 4131, 4132, 3, 1043, 521, 0, 4132, 4133, 3, 1043, 521, 0, 4133, 4134, 3, 1025, 512, 0, 4134, 4135, 3, 1021, 510, 0, 4135, 4136, 3, 1055, 527, 0, 4136, 4137, 3, 1045, 522, 0, 4137, 4138, 3, 1051, 525, 0, 4138, 708, 1, 0, 0, 0, 4139, 4140, 3, 1025, 512, 0, 4140, 4141, 3, 1063, 531, 0, 4141, 4142, 3, 1025, 512, 0, 4142, 4143, 3, 1021, 510, 0, 4143, 710, 1, 0, 0, 0, 4144, 4145, 3, 1055, 527, 0, 4145, 4146, 3, 1017, 508, 0, 4146, 4147, 3, 1019, 509, 0, 4147, 4148, 3, 1039, 519, 0, 4148, 4149, 3, 1025, 512, 0, 4149, 4150, 3, 1053, 526, 0, 4150, 712, 1, 0, 0, 0, 4151, 4152, 3, 1059, 529, 0, 4152, 4153, 3, 1033, 516, 0, 4153, 4154, 3, 1025, 512, 0, 4154, 4155, 3, 1061, 530, 0, 4155, 4156, 3, 1053, 526, 0, 4156, 714, 1, 0, 0, 0, 4157, 4158, 3, 1025, 512, 0, 4158, 4159, 3, 1063, 531, 0, 4159, 4160, 3, 1047, 523, 0, 4160, 4161, 3, 1045, 522, 0, 4161, 4162, 3, 1053, 526, 0, 4162, 4163, 3, 1025, 512, 0, 4163, 4164, 3, 1023, 511, 0, 4164, 716, 1, 0, 0, 0, 4165, 4166, 3, 1047, 523, 0, 4166, 4167, 3, 1017, 508, 0, 4167, 4168, 3, 1051, 525, 0, 4168, 4169, 3, 1017, 508, 0, 4169, 4170, 3, 1041, 520, 0, 4170, 4171, 3, 1025, 512, 0, 4171, 4172, 3, 1055, 527, 0, 4172, 4173, 3, 1025, 512, 0, 4173, 4174, 3, 1051, 525, 0, 4174, 718, 1, 0, 0, 0, 4175, 4176, 3, 1047, 523, 0, 4176, 4177, 3, 1017, 508, 0, 4177, 4178, 3, 1051, 525, 0, 4178, 4179, 3, 1017, 508, 0, 4179, 4180, 3, 1041, 520, 0, 4180, 4181, 3, 1025, 512, 0, 4181, 4182, 3, 1055, 527, 0, 4182, 4183, 3, 1025, 512, 0, 4183, 4184, 3, 1051, 525, 0, 4184, 4185, 3, 1053, 526, 0, 4185, 720, 1, 0, 0, 0, 4186, 4187, 3, 1031, 515, 0, 4187, 4188, 3, 1025, 512, 0, 4188, 4189, 3, 1017, 508, 0, 4189, 4190, 3, 1023, 511, 0, 4190, 4191, 3, 1025, 512, 0, 4191, 4192, 3, 1051, 525, 0, 4192, 4193, 3, 1053, 526, 0, 4193, 722, 1, 0, 0, 0, 4194, 4195, 3, 1043, 521, 0, 4195, 4196, 3, 1017, 508, 0, 4196, 4197, 3, 1059, 529, 0, 4197, 4198, 3, 1033, 516, 0, 4198, 4199, 3, 1029, 514, 0, 4199, 4200, 3, 1017, 508, 0, 4200, 4201, 3, 1055, 527, 0, 4201, 4202, 3, 1033, 516, 0, 4202, 4203, 3, 1045, 522, 0, 4203, 4204, 3, 1043, 521, 0, 4204, 724, 1, 0, 0, 0, 4205, 4206, 3, 1041, 520, 0, 4206, 4207, 3, 1025, 512, 0, 4207, 4208, 3, 1043, 521, 0, 4208, 4209, 3, 1057, 528, 0, 4209, 726, 1, 0, 0, 0, 4210, 4211, 3, 1031, 515, 0, 4211, 4212, 3, 1045, 522, 0, 4212, 4213, 3, 1041, 520, 0, 4213, 4214, 3, 1025, 512, 0, 4214, 4215, 3, 1053, 526, 0, 4215, 728, 1, 0, 0, 0, 4216, 4217, 3, 1031, 515, 0, 4217, 4218, 3, 1045, 522, 0, 4218, 4219, 3, 1041, 520, 0, 4219, 4220, 3, 1025, 512, 0, 4220, 730, 1, 0, 0, 0, 4221, 4222, 3, 1039, 519, 0, 4222, 4223, 3, 1045, 522, 0, 4223, 4224, 3, 1029, 514, 0, 4224, 4225, 3, 1033, 516, 0, 4225, 4226, 3, 1043, 521, 0, 4226, 732, 1, 0, 0, 0, 4227, 4228, 3, 1027, 513, 0, 4228, 4229, 3, 1045, 522, 0, 4229, 4230, 3, 1057, 528, 0, 4230, 4231, 3, 1043, 521, 0, 4231, 4232, 3, 1023, 511, 0, 4232, 734, 1, 0, 0, 0, 4233, 4234, 3, 1041, 520, 0, 4234, 4235, 3, 1045, 522, 0, 4235, 4236, 3, 1023, 511, 0, 4236, 4237, 3, 1057, 528, 0, 4237, 4238, 3, 1039, 519, 0, 4238, 4239, 3, 1025, 512, 0, 4239, 4240, 3, 1053, 526, 0, 4240, 736, 1, 0, 0, 0, 4241, 4242, 3, 1025, 512, 0, 4242, 4243, 3, 1043, 521, 0, 4243, 4244, 3, 1055, 527, 0, 4244, 4245, 3, 1033, 516, 0, 4245, 4246, 3, 1055, 527, 0, 4246, 4247, 3, 1033, 516, 0, 4247, 4248, 3, 1025, 512, 0, 4248, 4249, 3, 1053, 526, 0, 4249, 738, 1, 0, 0, 0, 4250, 4251, 3, 1017, 508, 0, 4251, 4252, 3, 1053, 526, 0, 4252, 4253, 3, 1053, 526, 0, 4253, 4254, 3, 1045, 522, 0, 4254, 4255, 3, 1021, 510, 0, 4255, 4256, 3, 1033, 516, 0, 4256, 4257, 3, 1017, 508, 0, 4257, 4258, 3, 1055, 527, 0, 4258, 4259, 3, 1033, 516, 0, 4259, 4260, 3, 1045, 522, 0, 4260, 4261, 3, 1043, 521, 0, 4261, 4262, 3, 1053, 526, 0, 4262, 740, 1, 0, 0, 0, 4263, 4264, 3, 1041, 520, 0, 4264, 4265, 3, 1033, 516, 0, 4265, 4266, 3, 1021, 510, 0, 4266, 4267, 3, 1051, 525, 0, 4267, 4268, 3, 1045, 522, 0, 4268, 4269, 3, 1027, 513, 0, 4269, 4270, 3, 1039, 519, 0, 4270, 4271, 3, 1045, 522, 0, 4271, 4272, 3, 1061, 530, 0, 4272, 4273, 3, 1053, 526, 0, 4273, 742, 1, 0, 0, 0, 4274, 4275, 3, 1043, 521, 0, 4275, 4276, 3, 1017, 508, 0, 4276, 4277, 3, 1043, 521, 0, 4277, 4278, 3, 1045, 522, 0, 4278, 4279, 3, 1027, 513, 0, 4279, 4280, 3, 1039, 519, 0, 4280, 4281, 3, 1045, 522, 0, 4281, 4282, 3, 1061, 530, 0, 4282, 4283, 3, 1053, 526, 0, 4283, 744, 1, 0, 0, 0, 4284, 4285, 3, 1061, 530, 0, 4285, 4286, 3, 1045, 522, 0, 4286, 4287, 3, 1051, 525, 0, 4287, 4288, 3, 1037, 518, 0, 4288, 4289, 3, 1027, 513, 0, 4289, 4290, 3, 1039, 519, 0, 4290, 4291, 3, 1045, 522, 0, 4291, 4292, 3, 1061, 530, 0, 4292, 4293, 3, 1053, 526, 0, 4293, 746, 1, 0, 0, 0, 4294, 4295, 3, 1025, 512, 0, 4295, 4296, 3, 1043, 521, 0, 4296, 4297, 3, 1057, 528, 0, 4297, 4298, 3, 1041, 520, 0, 4298, 4299, 3, 1025, 512, 0, 4299, 4300, 3, 1051, 525, 0, 4300, 4301, 3, 1017, 508, 0, 4301, 4302, 3, 1055, 527, 0, 4302, 4303, 3, 1033, 516, 0, 4303, 4304, 3, 1045, 522, 0, 4304, 4305, 3, 1043, 521, 0, 4305, 4306, 3, 1053, 526, 0, 4306, 748, 1, 0, 0, 0, 4307, 4308, 3, 1021, 510, 0, 4308, 4309, 3, 1045, 522, 0, 4309, 4310, 3, 1043, 521, 0, 4310, 4311, 3, 1053, 526, 0, 4311, 4312, 3, 1055, 527, 0, 4312, 4313, 3, 1017, 508, 0, 4313, 4314, 3, 1043, 521, 0, 4314, 4315, 3, 1055, 527, 0, 4315, 4316, 3, 1053, 526, 0, 4316, 750, 1, 0, 0, 0, 4317, 4318, 3, 1021, 510, 0, 4318, 4319, 3, 1045, 522, 0, 4319, 4320, 3, 1043, 521, 0, 4320, 4321, 3, 1043, 521, 0, 4321, 4322, 3, 1025, 512, 0, 4322, 4323, 3, 1021, 510, 0, 4323, 4324, 3, 1055, 527, 0, 4324, 4325, 3, 1033, 516, 0, 4325, 4326, 3, 1045, 522, 0, 4326, 4327, 3, 1043, 521, 0, 4327, 4328, 3, 1053, 526, 0, 4328, 752, 1, 0, 0, 0, 4329, 4330, 3, 1023, 511, 0, 4330, 4331, 3, 1025, 512, 0, 4331, 4332, 3, 1027, 513, 0, 4332, 4333, 3, 1033, 516, 0, 4333, 4334, 3, 1043, 521, 0, 4334, 4335, 3, 1025, 512, 0, 4335, 754, 1, 0, 0, 0, 4336, 4337, 3, 1027, 513, 0, 4337, 4338, 3, 1051, 525, 0, 4338, 4339, 3, 1017, 508, 0, 4339, 4340, 3, 1029, 514, 0, 4340, 4341, 3, 1041, 520, 0, 4341, 4342, 3, 1025, 512, 0, 4342, 4343, 3, 1043, 521, 0, 4343, 4344, 3, 1055, 527, 0, 4344, 756, 1, 0, 0, 0, 4345, 4346, 3, 1027, 513, 0, 4346, 4347, 3, 1051, 525, 0, 4347, 4348, 3, 1017, 508, 0, 4348, 4349, 3, 1029, 514, 0, 4349, 4350, 3, 1041, 520, 0, 4350, 4351, 3, 1025, 512, 0, 4351, 4352, 3, 1043, 521, 0, 4352, 4353, 3, 1055, 527, 0, 4353, 4354, 3, 1053, 526, 0, 4354, 758, 1, 0, 0, 0, 4355, 4356, 3, 1033, 516, 0, 4356, 4357, 3, 1043, 521, 0, 4357, 4358, 3, 1053, 526, 0, 4358, 4359, 3, 1025, 512, 0, 4359, 4360, 3, 1051, 525, 0, 4360, 4361, 3, 1055, 527, 0, 4361, 760, 1, 0, 0, 0, 4362, 4363, 3, 1019, 509, 0, 4363, 4364, 3, 1025, 512, 0, 4364, 4365, 3, 1027, 513, 0, 4365, 4366, 3, 1045, 522, 0, 4366, 4367, 3, 1051, 525, 0, 4367, 4368, 3, 1025, 512, 0, 4368, 762, 1, 0, 0, 0, 4369, 4370, 3, 1017, 508, 0, 4370, 4371, 3, 1027, 513, 0, 4371, 4372, 3, 1055, 527, 0, 4372, 4373, 3, 1025, 512, 0, 4373, 4374, 3, 1051, 525, 0, 4374, 764, 1, 0, 0, 0, 4375, 4376, 3, 1057, 528, 0, 4376, 4377, 3, 1047, 523, 0, 4377, 4378, 3, 1023, 511, 0, 4378, 4379, 3, 1017, 508, 0, 4379, 4380, 3, 1055, 527, 0, 4380, 4381, 3, 1025, 512, 0, 4381, 766, 1, 0, 0, 0, 4382, 4383, 3, 1051, 525, 0, 4383, 4384, 3, 1025, 512, 0, 4384, 4385, 3, 1027, 513, 0, 4385, 4386, 3, 1051, 525, 0, 4386, 4387, 3, 1025, 512, 0, 4387, 4388, 3, 1053, 526, 0, 4388, 4389, 3, 1031, 515, 0, 4389, 768, 1, 0, 0, 0, 4390, 4391, 3, 1021, 510, 0, 4391, 4392, 3, 1031, 515, 0, 4392, 4393, 3, 1025, 512, 0, 4393, 4394, 3, 1021, 510, 0, 4394, 4395, 3, 1037, 518, 0, 4395, 770, 1, 0, 0, 0, 4396, 4397, 3, 1019, 509, 0, 4397, 4398, 3, 1057, 528, 0, 4398, 4399, 3, 1033, 516, 0, 4399, 4400, 3, 1039, 519, 0, 4400, 4401, 3, 1023, 511, 0, 4401, 772, 1, 0, 0, 0, 4402, 4403, 3, 1025, 512, 0, 4403, 4404, 3, 1063, 531, 0, 4404, 4405, 3, 1025, 512, 0, 4405, 4406, 3, 1021, 510, 0, 4406, 4407, 3, 1057, 528, 0, 4407, 4408, 3, 1055, 527, 0, 4408, 4409, 3, 1025, 512, 0, 4409, 774, 1, 0, 0, 0, 4410, 4411, 3, 1053, 526, 0, 4411, 4412, 3, 1021, 510, 0, 4412, 4413, 3, 1051, 525, 0, 4413, 4414, 3, 1033, 516, 0, 4414, 4415, 3, 1047, 523, 0, 4415, 4416, 3, 1055, 527, 0, 4416, 776, 1, 0, 0, 0, 4417, 4418, 3, 1039, 519, 0, 4418, 4419, 3, 1033, 516, 0, 4419, 4420, 3, 1043, 521, 0, 4420, 4421, 3, 1055, 527, 0, 4421, 778, 1, 0, 0, 0, 4422, 4423, 3, 1051, 525, 0, 4423, 4424, 3, 1057, 528, 0, 4424, 4425, 3, 1039, 519, 0, 4425, 4426, 3, 1025, 512, 0, 4426, 4427, 3, 1053, 526, 0, 4427, 780, 1, 0, 0, 0, 4428, 4429, 3, 1055, 527, 0, 4429, 4430, 3, 1025, 512, 0, 4430, 4431, 3, 1063, 531, 0, 4431, 4432, 3, 1055, 527, 0, 4432, 782, 1, 0, 0, 0, 4433, 4434, 3, 1053, 526, 0, 4434, 4435, 3, 1017, 508, 0, 4435, 4436, 3, 1051, 525, 0, 4436, 4437, 3, 1033, 516, 0, 4437, 4438, 3, 1027, 513, 0, 4438, 784, 1, 0, 0, 0, 4439, 4440, 3, 1041, 520, 0, 4440, 4441, 3, 1025, 512, 0, 4441, 4442, 3, 1053, 526, 0, 4442, 4443, 3, 1053, 526, 0, 4443, 4444, 3, 1017, 508, 0, 4444, 4445, 3, 1029, 514, 0, 4445, 4446, 3, 1025, 512, 0, 4446, 786, 1, 0, 0, 0, 4447, 4448, 3, 1021, 510, 0, 4448, 4449, 3, 1045, 522, 0, 4449, 4450, 3, 1041, 520, 0, 4450, 4451, 3, 1041, 520, 0, 4451, 4452, 3, 1025, 512, 0, 4452, 4453, 3, 1043, 521, 0, 4453, 4454, 3, 1055, 527, 0, 4454, 788, 1, 0, 0, 0, 4455, 4456, 3, 1021, 510, 0, 4456, 4457, 3, 1017, 508, 0, 4457, 4458, 3, 1055, 527, 0, 4458, 4459, 3, 1017, 508, 0, 4459, 4460, 3, 1039, 519, 0, 4460, 4461, 3, 1045, 522, 0, 4461, 4462, 3, 1029, 514, 0, 4462, 790, 1, 0, 0, 0, 4463, 4464, 3, 1027, 513, 0, 4464, 4465, 3, 1045, 522, 0, 4465, 4466, 3, 1051, 525, 0, 4466, 4467, 3, 1021, 510, 0, 4467, 4468, 3, 1025, 512, 0, 4468, 792, 1, 0, 0, 0, 4469, 4470, 3, 1019, 509, 0, 4470, 4471, 3, 1017, 508, 0, 4471, 4472, 3, 1021, 510, 0, 4472, 4473, 3, 1037, 518, 0, 4473, 4474, 3, 1029, 514, 0, 4474, 4475, 3, 1051, 525, 0, 4475, 4476, 3, 1045, 522, 0, 4476, 4477, 3, 1057, 528, 0, 4477, 4478, 3, 1043, 521, 0, 4478, 4479, 3, 1023, 511, 0, 4479, 794, 1, 0, 0, 0, 4480, 4481, 3, 1021, 510, 0, 4481, 4482, 3, 1017, 508, 0, 4482, 4483, 3, 1039, 519, 0, 4483, 4484, 3, 1039, 519, 0, 4484, 4485, 3, 1025, 512, 0, 4485, 4486, 3, 1051, 525, 0, 4486, 4487, 3, 1053, 526, 0, 4487, 796, 1, 0, 0, 0, 4488, 4489, 3, 1021, 510, 0, 4489, 4490, 3, 1017, 508, 0, 4490, 4491, 3, 1039, 519, 0, 4491, 4492, 3, 1039, 519, 0, 4492, 4493, 3, 1025, 512, 0, 4493, 4494, 3, 1025, 512, 0, 4494, 4495, 3, 1053, 526, 0, 4495, 798, 1, 0, 0, 0, 4496, 4497, 3, 1051, 525, 0, 4497, 4498, 3, 1025, 512, 0, 4498, 4499, 3, 1027, 513, 0, 4499, 4500, 3, 1025, 512, 0, 4500, 4501, 3, 1051, 525, 0, 4501, 4502, 3, 1025, 512, 0, 4502, 4503, 3, 1043, 521, 0, 4503, 4504, 3, 1021, 510, 0, 4504, 4505, 3, 1025, 512, 0, 4505, 4506, 3, 1053, 526, 0, 4506, 800, 1, 0, 0, 0, 4507, 4508, 3, 1055, 527, 0, 4508, 4509, 3, 1051, 525, 0, 4509, 4510, 3, 1017, 508, 0, 4510, 4511, 3, 1043, 521, 0, 4511, 4512, 3, 1053, 526, 0, 4512, 4513, 3, 1033, 516, 0, 4513, 4514, 3, 1055, 527, 0, 4514, 4515, 3, 1033, 516, 0, 4515, 4516, 3, 1059, 529, 0, 4516, 4517, 3, 1025, 512, 0, 4517, 802, 1, 0, 0, 0, 4518, 4519, 3, 1033, 516, 0, 4519, 4520, 3, 1041, 520, 0, 4520, 4521, 3, 1047, 523, 0, 4521, 4522, 3, 1017, 508, 0, 4522, 4523, 3, 1021, 510, 0, 4523, 4524, 3, 1055, 527, 0, 4524, 804, 1, 0, 0, 0, 4525, 4526, 3, 1023, 511, 0, 4526, 4527, 3, 1025, 512, 0, 4527, 4528, 3, 1047, 523, 0, 4528, 4529, 3, 1055, 527, 0, 4529, 4530, 3, 1031, 515, 0, 4530, 806, 1, 0, 0, 0, 4531, 4532, 3, 1053, 526, 0, 4532, 4533, 3, 1055, 527, 0, 4533, 4534, 3, 1051, 525, 0, 4534, 4535, 3, 1057, 528, 0, 4535, 4536, 3, 1021, 510, 0, 4536, 4537, 3, 1055, 527, 0, 4537, 4538, 3, 1057, 528, 0, 4538, 4539, 3, 1051, 525, 0, 4539, 4540, 3, 1025, 512, 0, 4540, 808, 1, 0, 0, 0, 4541, 4542, 3, 1055, 527, 0, 4542, 4543, 3, 1065, 532, 0, 4543, 4544, 3, 1047, 523, 0, 4544, 4545, 3, 1025, 512, 0, 4545, 810, 1, 0, 0, 0, 4546, 4547, 3, 1059, 529, 0, 4547, 4548, 3, 1017, 508, 0, 4548, 4549, 3, 1039, 519, 0, 4549, 4550, 3, 1057, 528, 0, 4550, 4551, 3, 1025, 512, 0, 4551, 812, 1, 0, 0, 0, 4552, 4553, 3, 1053, 526, 0, 4553, 4554, 3, 1033, 516, 0, 4554, 4555, 3, 1043, 521, 0, 4555, 4556, 3, 1029, 514, 0, 4556, 4557, 3, 1039, 519, 0, 4557, 4558, 3, 1025, 512, 0, 4558, 814, 1, 0, 0, 0, 4559, 4560, 3, 1041, 520, 0, 4560, 4561, 3, 1057, 528, 0, 4561, 4562, 3, 1039, 519, 0, 4562, 4563, 3, 1055, 527, 0, 4563, 4564, 3, 1033, 516, 0, 4564, 4565, 3, 1047, 523, 0, 4565, 4566, 3, 1039, 519, 0, 4566, 4567, 3, 1025, 512, 0, 4567, 816, 1, 0, 0, 0, 4568, 4569, 3, 1043, 521, 0, 4569, 4570, 3, 1045, 522, 0, 4570, 4571, 3, 1043, 521, 0, 4571, 4572, 3, 1025, 512, 0, 4572, 818, 1, 0, 0, 0, 4573, 4574, 3, 1019, 509, 0, 4574, 4575, 3, 1045, 522, 0, 4575, 4576, 3, 1055, 527, 0, 4576, 4577, 3, 1031, 515, 0, 4577, 820, 1, 0, 0, 0, 4578, 4579, 3, 1055, 527, 0, 4579, 4580, 3, 1045, 522, 0, 4580, 822, 1, 0, 0, 0, 4581, 4582, 3, 1045, 522, 0, 4582, 4583, 3, 1027, 513, 0, 4583, 824, 1, 0, 0, 0, 4584, 4585, 3, 1045, 522, 0, 4585, 4586, 3, 1059, 529, 0, 4586, 4587, 3, 1025, 512, 0, 4587, 4588, 3, 1051, 525, 0, 4588, 826, 1, 0, 0, 0, 4589, 4590, 3, 1027, 513, 0, 4590, 4591, 3, 1045, 522, 0, 4591, 4592, 3, 1051, 525, 0, 4592, 828, 1, 0, 0, 0, 4593, 4594, 3, 1051, 525, 0, 4594, 4595, 3, 1025, 512, 0, 4595, 4596, 3, 1047, 523, 0, 4596, 4597, 3, 1039, 519, 0, 4597, 4598, 3, 1017, 508, 0, 4598, 4599, 3, 1021, 510, 0, 4599, 4600, 3, 1025, 512, 0, 4600, 830, 1, 0, 0, 0, 4601, 4602, 3, 1041, 520, 0, 4602, 4603, 3, 1025, 512, 0, 4603, 4604, 3, 1041, 520, 0, 4604, 4605, 3, 1019, 509, 0, 4605, 4606, 3, 1025, 512, 0, 4606, 4607, 3, 1051, 525, 0, 4607, 4608, 3, 1053, 526, 0, 4608, 832, 1, 0, 0, 0, 4609, 4610, 3, 1017, 508, 0, 4610, 4611, 3, 1055, 527, 0, 4611, 4612, 3, 1055, 527, 0, 4612, 4613, 3, 1051, 525, 0, 4613, 4614, 3, 1033, 516, 0, 4614, 4615, 3, 1019, 509, 0, 4615, 4616, 3, 1057, 528, 0, 4616, 4617, 3, 1055, 527, 0, 4617, 4618, 3, 1025, 512, 0, 4618, 4619, 3, 1043, 521, 0, 4619, 4620, 3, 1017, 508, 0, 4620, 4621, 3, 1041, 520, 0, 4621, 4622, 3, 1025, 512, 0, 4622, 834, 1, 0, 0, 0, 4623, 4624, 3, 1027, 513, 0, 4624, 4625, 3, 1045, 522, 0, 4625, 4626, 3, 1051, 525, 0, 4626, 4627, 3, 1041, 520, 0, 4627, 4628, 3, 1017, 508, 0, 4628, 4629, 3, 1055, 527, 0, 4629, 836, 1, 0, 0, 0, 4630, 4631, 3, 1053, 526, 0, 4631, 4632, 3, 1049, 524, 0, 4632, 4633, 3, 1039, 519, 0, 4633, 838, 1, 0, 0, 0, 4634, 4635, 3, 1061, 530, 0, 4635, 4636, 3, 1033, 516, 0, 4636, 4637, 3, 1055, 527, 0, 4637, 4638, 3, 1031, 515, 0, 4638, 4639, 3, 1045, 522, 0, 4639, 4640, 3, 1057, 528, 0, 4640, 4641, 3, 1055, 527, 0, 4641, 840, 1, 0, 0, 0, 4642, 4643, 3, 1023, 511, 0, 4643, 4644, 3, 1051, 525, 0, 4644, 4645, 3, 1065, 532, 0, 4645, 842, 1, 0, 0, 0, 4646, 4647, 3, 1051, 525, 0, 4647, 4648, 3, 1057, 528, 0, 4648, 4649, 3, 1043, 521, 0, 4649, 844, 1, 0, 0, 0, 4650, 4651, 3, 1061, 530, 0, 4651, 4652, 3, 1033, 516, 0, 4652, 4653, 3, 1023, 511, 0, 4653, 4654, 3, 1029, 514, 0, 4654, 4655, 3, 1025, 512, 0, 4655, 4656, 3, 1055, 527, 0, 4656, 4657, 3, 1055, 527, 0, 4657, 4658, 3, 1065, 532, 0, 4658, 4659, 3, 1047, 523, 0, 4659, 4660, 3, 1025, 512, 0, 4660, 846, 1, 0, 0, 0, 4661, 4662, 3, 1059, 529, 0, 4662, 4663, 5, 51, 0, 0, 4663, 848, 1, 0, 0, 0, 4664, 4665, 3, 1019, 509, 0, 4665, 4666, 3, 1057, 528, 0, 4666, 4667, 3, 1053, 526, 0, 4667, 4668, 3, 1033, 516, 0, 4668, 4669, 3, 1043, 521, 0, 4669, 4670, 3, 1025, 512, 0, 4670, 4671, 3, 1053, 526, 0, 4671, 4672, 3, 1053, 526, 0, 4672, 850, 1, 0, 0, 0, 4673, 4674, 3, 1025, 512, 0, 4674, 4675, 3, 1059, 529, 0, 4675, 4676, 3, 1025, 512, 0, 4676, 4677, 3, 1043, 521, 0, 4677, 4678, 3, 1055, 527, 0, 4678, 852, 1, 0, 0, 0, 4679, 4680, 3, 1053, 526, 0, 4680, 4681, 3, 1057, 528, 0, 4681, 4682, 3, 1019, 509, 0, 4682, 4683, 3, 1053, 526, 0, 4683, 4684, 3, 1021, 510, 0, 4684, 4685, 3, 1051, 525, 0, 4685, 4686, 3, 1033, 516, 0, 4686, 4687, 3, 1019, 509, 0, 4687, 4688, 3, 1025, 512, 0, 4688, 854, 1, 0, 0, 0, 4689, 4690, 3, 1053, 526, 0, 4690, 4691, 3, 1025, 512, 0, 4691, 4692, 3, 1055, 527, 0, 4692, 4693, 3, 1055, 527, 0, 4693, 4694, 3, 1033, 516, 0, 4694, 4695, 3, 1043, 521, 0, 4695, 4696, 3, 1029, 514, 0, 4696, 4697, 3, 1053, 526, 0, 4697, 856, 1, 0, 0, 0, 4698, 4699, 3, 1021, 510, 0, 4699, 4700, 3, 1045, 522, 0, 4700, 4701, 3, 1043, 521, 0, 4701, 4702, 3, 1027, 513, 0, 4702, 4703, 3, 1033, 516, 0, 4703, 4704, 3, 1029, 514, 0, 4704, 4705, 3, 1057, 528, 0, 4705, 4706, 3, 1051, 525, 0, 4706, 4707, 3, 1017, 508, 0, 4707, 4708, 3, 1055, 527, 0, 4708, 4709, 3, 1033, 516, 0, 4709, 4710, 3, 1045, 522, 0, 4710, 4711, 3, 1043, 521, 0, 4711, 858, 1, 0, 0, 0, 4712, 4713, 3, 1053, 526, 0, 4713, 4714, 3, 1025, 512, 0, 4714, 4715, 3, 1021, 510, 0, 4715, 4716, 3, 1057, 528, 0, 4716, 4717, 3, 1051, 525, 0, 4717, 4718, 3, 1033, 516, 0, 4718, 4719, 3, 1055, 527, 0, 4719, 4720, 3, 1065, 532, 0, 4720, 860, 1, 0, 0, 0, 4721, 4722, 3, 1051, 525, 0, 4722, 4723, 3, 1045, 522, 0, 4723, 4724, 3, 1039, 519, 0, 4724, 4725, 3, 1025, 512, 0, 4725, 862, 1, 0, 0, 0, 4726, 4727, 3, 1051, 525, 0, 4727, 4728, 3, 1045, 522, 0, 4728, 4729, 3, 1039, 519, 0, 4729, 4730, 3, 1025, 512, 0, 4730, 4731, 3, 1053, 526, 0, 4731, 864, 1, 0, 0, 0, 4732, 4733, 3, 1029, 514, 0, 4733, 4734, 3, 1051, 525, 0, 4734, 4735, 3, 1017, 508, 0, 4735, 4736, 3, 1043, 521, 0, 4736, 4737, 3, 1055, 527, 0, 4737, 866, 1, 0, 0, 0, 4738, 4739, 3, 1051, 525, 0, 4739, 4740, 3, 1025, 512, 0, 4740, 4741, 3, 1059, 529, 0, 4741, 4742, 3, 1045, 522, 0, 4742, 4743, 3, 1037, 518, 0, 4743, 4744, 3, 1025, 512, 0, 4744, 868, 1, 0, 0, 0, 4745, 4746, 3, 1047, 523, 0, 4746, 4747, 3, 1051, 525, 0, 4747, 4748, 3, 1045, 522, 0, 4748, 4749, 3, 1023, 511, 0, 4749, 4750, 3, 1057, 528, 0, 4750, 4751, 3, 1021, 510, 0, 4751, 4752, 3, 1055, 527, 0, 4752, 4753, 3, 1033, 516, 0, 4753, 4754, 3, 1045, 522, 0, 4754, 4755, 3, 1043, 521, 0, 4755, 870, 1, 0, 0, 0, 4756, 4757, 3, 1047, 523, 0, 4757, 4758, 3, 1051, 525, 0, 4758, 4759, 3, 1045, 522, 0, 4759, 4760, 3, 1055, 527, 0, 4760, 4761, 3, 1045, 522, 0, 4761, 4762, 3, 1055, 527, 0, 4762, 4763, 3, 1065, 532, 0, 4763, 4764, 3, 1047, 523, 0, 4764, 4765, 3, 1025, 512, 0, 4765, 872, 1, 0, 0, 0, 4766, 4767, 3, 1041, 520, 0, 4767, 4768, 3, 1017, 508, 0, 4768, 4769, 3, 1043, 521, 0, 4769, 4770, 3, 1017, 508, 0, 4770, 4771, 3, 1029, 514, 0, 4771, 4772, 3, 1025, 512, 0, 4772, 874, 1, 0, 0, 0, 4773, 4774, 3, 1023, 511, 0, 4774, 4775, 3, 1025, 512, 0, 4775, 4776, 3, 1041, 520, 0, 4776, 4777, 3, 1045, 522, 0, 4777, 876, 1, 0, 0, 0, 4778, 4779, 3, 1041, 520, 0, 4779, 4780, 3, 1017, 508, 0, 4780, 4781, 3, 1055, 527, 0, 4781, 4782, 3, 1051, 525, 0, 4782, 4783, 3, 1033, 516, 0, 4783, 4784, 3, 1063, 531, 0, 4784, 878, 1, 0, 0, 0, 4785, 4786, 3, 1017, 508, 0, 4786, 4787, 3, 1047, 523, 0, 4787, 4788, 3, 1047, 523, 0, 4788, 4789, 3, 1039, 519, 0, 4789, 4790, 3, 1065, 532, 0, 4790, 880, 1, 0, 0, 0, 4791, 4792, 3, 1017, 508, 0, 4792, 4793, 3, 1021, 510, 0, 4793, 4794, 3, 1021, 510, 0, 4794, 4795, 3, 1025, 512, 0, 4795, 4796, 3, 1053, 526, 0, 4796, 4797, 3, 1053, 526, 0, 4797, 882, 1, 0, 0, 0, 4798, 4799, 3, 1039, 519, 0, 4799, 4800, 3, 1025, 512, 0, 4800, 4801, 3, 1059, 529, 0, 4801, 4802, 3, 1025, 512, 0, 4802, 4803, 3, 1039, 519, 0, 4803, 884, 1, 0, 0, 0, 4804, 4805, 3, 1057, 528, 0, 4805, 4806, 3, 1053, 526, 0, 4806, 4807, 3, 1025, 512, 0, 4807, 4808, 3, 1051, 525, 0, 4808, 886, 1, 0, 0, 0, 4809, 4810, 3, 1055, 527, 0, 4810, 4811, 3, 1017, 508, 0, 4811, 4812, 3, 1053, 526, 0, 4812, 4813, 3, 1037, 518, 0, 4813, 888, 1, 0, 0, 0, 4814, 4815, 3, 1023, 511, 0, 4815, 4816, 3, 1025, 512, 0, 4816, 4817, 3, 1021, 510, 0, 4817, 4818, 3, 1033, 516, 0, 4818, 4819, 3, 1053, 526, 0, 4819, 4820, 3, 1033, 516, 0, 4820, 4821, 3, 1045, 522, 0, 4821, 4822, 3, 1043, 521, 0, 4822, 890, 1, 0, 0, 0, 4823, 4824, 3, 1053, 526, 0, 4824, 4825, 3, 1047, 523, 0, 4825, 4826, 3, 1039, 519, 0, 4826, 4827, 3, 1033, 516, 0, 4827, 4828, 3, 1055, 527, 0, 4828, 892, 1, 0, 0, 0, 4829, 4830, 3, 1045, 522, 0, 4830, 4831, 3, 1057, 528, 0, 4831, 4832, 3, 1055, 527, 0, 4832, 4833, 3, 1021, 510, 0, 4833, 4834, 3, 1045, 522, 0, 4834, 4835, 3, 1041, 520, 0, 4835, 4836, 3, 1025, 512, 0, 4836, 4837, 3, 1053, 526, 0, 4837, 894, 1, 0, 0, 0, 4838, 4839, 3, 1055, 527, 0, 4839, 4840, 3, 1017, 508, 0, 4840, 4841, 3, 1051, 525, 0, 4841, 4842, 3, 1029, 514, 0, 4842, 4843, 3, 1025, 512, 0, 4843, 4844, 3, 1055, 527, 0, 4844, 4845, 3, 1033, 516, 0, 4845, 4846, 3, 1043, 521, 0, 4846, 4847, 3, 1029, 514, 0, 4847, 896, 1, 0, 0, 0, 4848, 4849, 3, 1043, 521, 0, 4849, 4850, 3, 1045, 522, 0, 4850, 4851, 3, 1055, 527, 0, 4851, 4852, 3, 1033, 516, 0, 4852, 4853, 3, 1027, 513, 0, 4853, 4854, 3, 1033, 516, 0, 4854, 4855, 3, 1021, 510, 0, 4855, 4856, 3, 1017, 508, 0, 4856, 4857, 3, 1055, 527, 0, 4857, 4858, 3, 1033, 516, 0, 4858, 4859, 3, 1045, 522, 0, 4859, 4860, 3, 1043, 521, 0, 4860, 898, 1, 0, 0, 0, 4861, 4862, 3, 1055, 527, 0, 4862, 4863, 3, 1033, 516, 0, 4863, 4864, 3, 1041, 520, 0, 4864, 4865, 3, 1025, 512, 0, 4865, 4866, 3, 1051, 525, 0, 4866, 900, 1, 0, 0, 0, 4867, 4868, 3, 1035, 517, 0, 4868, 4869, 3, 1057, 528, 0, 4869, 4870, 3, 1041, 520, 0, 4870, 4871, 3, 1047, 523, 0, 4871, 902, 1, 0, 0, 0, 4872, 4873, 3, 1023, 511, 0, 4873, 4874, 3, 1057, 528, 0, 4874, 4875, 3, 1025, 512, 0, 4875, 904, 1, 0, 0, 0, 4876, 4877, 3, 1045, 522, 0, 4877, 4878, 3, 1059, 529, 0, 4878, 4879, 3, 1025, 512, 0, 4879, 4880, 3, 1051, 525, 0, 4880, 4881, 3, 1059, 529, 0, 4881, 4882, 3, 1033, 516, 0, 4882, 4883, 3, 1025, 512, 0, 4883, 4884, 3, 1061, 530, 0, 4884, 906, 1, 0, 0, 0, 4885, 4886, 3, 1023, 511, 0, 4886, 4887, 3, 1017, 508, 0, 4887, 4888, 3, 1055, 527, 0, 4888, 4889, 3, 1025, 512, 0, 4889, 908, 1, 0, 0, 0, 4890, 4891, 3, 1047, 523, 0, 4891, 4892, 3, 1017, 508, 0, 4892, 4893, 3, 1051, 525, 0, 4893, 4894, 3, 1017, 508, 0, 4894, 4895, 3, 1039, 519, 0, 4895, 4896, 3, 1039, 519, 0, 4896, 4897, 3, 1025, 512, 0, 4897, 4898, 3, 1039, 519, 0, 4898, 910, 1, 0, 0, 0, 4899, 4900, 3, 1061, 530, 0, 4900, 4901, 3, 1017, 508, 0, 4901, 4902, 3, 1033, 516, 0, 4902, 4903, 3, 1055, 527, 0, 4903, 912, 1, 0, 0, 0, 4904, 4905, 3, 1017, 508, 0, 4905, 4906, 3, 1043, 521, 0, 4906, 4907, 3, 1043, 521, 0, 4907, 4908, 3, 1045, 522, 0, 4908, 4909, 3, 1055, 527, 0, 4909, 4910, 3, 1017, 508, 0, 4910, 4911, 3, 1055, 527, 0, 4911, 4912, 3, 1033, 516, 0, 4912, 4913, 3, 1045, 522, 0, 4913, 4914, 3, 1043, 521, 0, 4914, 914, 1, 0, 0, 0, 4915, 4916, 3, 1019, 509, 0, 4916, 4917, 3, 1045, 522, 0, 4917, 4918, 3, 1057, 528, 0, 4918, 4919, 3, 1043, 521, 0, 4919, 4920, 3, 1023, 511, 0, 4920, 4921, 3, 1017, 508, 0, 4921, 4922, 3, 1051, 525, 0, 4922, 4923, 3, 1065, 532, 0, 4923, 916, 1, 0, 0, 0, 4924, 4925, 3, 1033, 516, 0, 4925, 4926, 3, 1043, 521, 0, 4926, 4927, 3, 1055, 527, 0, 4927, 4928, 3, 1025, 512, 0, 4928, 4929, 3, 1051, 525, 0, 4929, 4930, 3, 1051, 525, 0, 4930, 4931, 3, 1057, 528, 0, 4931, 4932, 3, 1047, 523, 0, 4932, 4933, 3, 1055, 527, 0, 4933, 4934, 3, 1033, 516, 0, 4934, 4935, 3, 1043, 521, 0, 4935, 4936, 3, 1029, 514, 0, 4936, 918, 1, 0, 0, 0, 4937, 4938, 3, 1043, 521, 0, 4938, 4939, 3, 1045, 522, 0, 4939, 4940, 3, 1043, 521, 0, 4940, 920, 1, 0, 0, 0, 4941, 4942, 3, 1041, 520, 0, 4942, 4943, 3, 1057, 528, 0, 4943, 4944, 3, 1039, 519, 0, 4944, 4945, 3, 1055, 527, 0, 4945, 4946, 3, 1033, 516, 0, 4946, 922, 1, 0, 0, 0, 4947, 4948, 3, 1019, 509, 0, 4948, 4949, 3, 1065, 532, 0, 4949, 924, 1, 0, 0, 0, 4950, 4951, 3, 1051, 525, 0, 4951, 4952, 3, 1025, 512, 0, 4952, 4953, 3, 1017, 508, 0, 4953, 4954, 3, 1023, 511, 0, 4954, 926, 1, 0, 0, 0, 4955, 4956, 3, 1061, 530, 0, 4956, 4957, 3, 1051, 525, 0, 4957, 4958, 3, 1033, 516, 0, 4958, 4959, 3, 1055, 527, 0, 4959, 4960, 3, 1025, 512, 0, 4960, 928, 1, 0, 0, 0, 4961, 4962, 3, 1023, 511, 0, 4962, 4963, 3, 1025, 512, 0, 4963, 4964, 3, 1053, 526, 0, 4964, 4965, 3, 1021, 510, 0, 4965, 4966, 3, 1051, 525, 0, 4966, 4967, 3, 1033, 516, 0, 4967, 4968, 3, 1047, 523, 0, 4968, 4969, 3, 1055, 527, 0, 4969, 4970, 3, 1033, 516, 0, 4970, 4971, 3, 1045, 522, 0, 4971, 4972, 3, 1043, 521, 0, 4972, 930, 1, 0, 0, 0, 4973, 4974, 3, 1023, 511, 0, 4974, 4975, 3, 1033, 516, 0, 4975, 4976, 3, 1053, 526, 0, 4976, 4977, 3, 1047, 523, 0, 4977, 4978, 3, 1039, 519, 0, 4978, 4979, 3, 1017, 508, 0, 4979, 4980, 3, 1065, 532, 0, 4980, 932, 1, 0, 0, 0, 4981, 4982, 3, 1045, 522, 0, 4982, 4983, 3, 1027, 513, 0, 4983, 4984, 3, 1027, 513, 0, 4984, 934, 1, 0, 0, 0, 4985, 4986, 3, 1057, 528, 0, 4986, 4987, 3, 1053, 526, 0, 4987, 4988, 3, 1025, 512, 0, 4988, 4989, 3, 1051, 525, 0, 4989, 4990, 3, 1053, 526, 0, 4990, 936, 1, 0, 0, 0, 4991, 4992, 5, 60, 0, 0, 4992, 4996, 5, 62, 0, 0, 4993, 4994, 5, 33, 0, 0, 4994, 4996, 5, 61, 0, 0, 4995, 4991, 1, 0, 0, 0, 4995, 4993, 1, 0, 0, 0, 4996, 938, 1, 0, 0, 0, 4997, 4998, 5, 60, 0, 0, 4998, 4999, 5, 61, 0, 0, 4999, 940, 1, 0, 0, 0, 5000, 5001, 5, 62, 0, 0, 5001, 5002, 5, 61, 0, 0, 5002, 942, 1, 0, 0, 0, 5003, 5004, 5, 61, 0, 0, 5004, 944, 1, 0, 0, 0, 5005, 5006, 5, 60, 0, 0, 5006, 946, 1, 0, 0, 0, 5007, 5008, 5, 62, 0, 0, 5008, 948, 1, 0, 0, 0, 5009, 5010, 5, 43, 0, 0, 5010, 950, 1, 0, 0, 0, 5011, 5012, 5, 45, 0, 0, 5012, 952, 1, 0, 0, 0, 5013, 5014, 5, 42, 0, 0, 5014, 954, 1, 0, 0, 0, 5015, 5016, 5, 47, 0, 0, 5016, 956, 1, 0, 0, 0, 5017, 5018, 5, 37, 0, 0, 5018, 958, 1, 0, 0, 0, 5019, 5020, 3, 1041, 520, 0, 5020, 5021, 3, 1045, 522, 0, 5021, 5022, 3, 1023, 511, 0, 5022, 960, 1, 0, 0, 0, 5023, 5024, 3, 1023, 511, 0, 5024, 5025, 3, 1033, 516, 0, 5025, 5026, 3, 1059, 529, 0, 5026, 962, 1, 0, 0, 0, 5027, 5028, 5, 59, 0, 0, 5028, 964, 1, 0, 0, 0, 5029, 5030, 5, 44, 0, 0, 5030, 966, 1, 0, 0, 0, 5031, 5032, 5, 46, 0, 0, 5032, 968, 1, 0, 0, 0, 5033, 5034, 5, 40, 0, 0, 5034, 970, 1, 0, 0, 0, 5035, 5036, 5, 41, 0, 0, 5036, 972, 1, 0, 0, 0, 5037, 5038, 5, 123, 0, 0, 5038, 974, 1, 0, 0, 0, 5039, 5040, 5, 125, 0, 0, 5040, 976, 1, 0, 0, 0, 5041, 5042, 5, 91, 0, 0, 5042, 978, 1, 0, 0, 0, 5043, 5044, 5, 93, 0, 0, 5044, 980, 1, 0, 0, 0, 5045, 5046, 5, 58, 0, 0, 5046, 982, 1, 0, 0, 0, 5047, 5048, 5, 64, 0, 0, 5048, 984, 1, 0, 0, 0, 5049, 5050, 5, 124, 0, 0, 5050, 986, 1, 0, 0, 0, 5051, 5052, 5, 58, 0, 0, 5052, 5053, 5, 58, 0, 0, 5053, 988, 1, 0, 0, 0, 5054, 5055, 5, 45, 0, 0, 5055, 5056, 5, 62, 0, 0, 5056, 990, 1, 0, 0, 0, 5057, 5058, 5, 63, 0, 0, 5058, 992, 1, 0, 0, 0, 5059, 5060, 5, 35, 0, 0, 5060, 994, 1, 0, 0, 0, 5061, 5062, 5, 91, 0, 0, 5062, 5063, 5, 37, 0, 0, 5063, 5067, 1, 0, 0, 0, 5064, 5066, 9, 0, 0, 0, 5065, 5064, 1, 0, 0, 0, 5066, 5069, 1, 0, 0, 0, 5067, 5068, 1, 0, 0, 0, 5067, 5065, 1, 0, 0, 0, 5068, 5070, 1, 0, 0, 0, 5069, 5067, 1, 0, 0, 0, 5070, 5071, 5, 37, 0, 0, 5071, 5072, 5, 93, 0, 0, 5072, 996, 1, 0, 0, 0, 5073, 5081, 5, 39, 0, 0, 5074, 5080, 8, 2, 0, 0, 5075, 5076, 5, 92, 0, 0, 5076, 5080, 9, 0, 0, 0, 5077, 5078, 5, 39, 0, 0, 5078, 5080, 5, 39, 0, 0, 5079, 5074, 1, 0, 0, 0, 5079, 5075, 1, 0, 0, 0, 5079, 5077, 1, 0, 0, 0, 5080, 5083, 1, 0, 0, 0, 5081, 5079, 1, 0, 0, 0, 5081, 5082, 1, 0, 0, 0, 5082, 5084, 1, 0, 0, 0, 5083, 5081, 1, 0, 0, 0, 5084, 5085, 5, 39, 0, 0, 5085, 998, 1, 0, 0, 0, 5086, 5087, 5, 36, 0, 0, 5087, 5088, 5, 36, 0, 0, 5088, 5092, 1, 0, 0, 0, 5089, 5091, 9, 0, 0, 0, 5090, 5089, 1, 0, 0, 0, 5091, 5094, 1, 0, 0, 0, 5092, 5093, 1, 0, 0, 0, 5092, 5090, 1, 0, 0, 0, 5093, 5095, 1, 0, 0, 0, 5094, 5092, 1, 0, 0, 0, 5095, 5096, 5, 36, 0, 0, 5096, 5097, 5, 36, 0, 0, 5097, 1000, 1, 0, 0, 0, 5098, 5100, 5, 45, 0, 0, 5099, 5098, 1, 0, 0, 0, 5099, 5100, 1, 0, 0, 0, 5100, 5102, 1, 0, 0, 0, 5101, 5103, 3, 1015, 507, 0, 5102, 5101, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5102, 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 5112, 1, 0, 0, 0, 5106, 5108, 5, 46, 0, 0, 5107, 5109, 3, 1015, 507, 0, 5108, 5107, 1, 0, 0, 0, 5109, 5110, 1, 0, 0, 0, 5110, 5108, 1, 0, 0, 0, 5110, 5111, 1, 0, 0, 0, 5111, 5113, 1, 0, 0, 0, 5112, 5106, 1, 0, 0, 0, 5112, 5113, 1, 0, 0, 0, 5113, 5123, 1, 0, 0, 0, 5114, 5116, 7, 3, 0, 0, 5115, 5117, 7, 4, 0, 0, 5116, 5115, 1, 0, 0, 0, 5116, 5117, 1, 0, 0, 0, 5117, 5119, 1, 0, 0, 0, 5118, 5120, 3, 1015, 507, 0, 5119, 5118, 1, 0, 0, 0, 5120, 5121, 1, 0, 0, 0, 5121, 5119, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 5124, 1, 0, 0, 0, 5123, 5114, 1, 0, 0, 0, 5123, 5124, 1, 0, 0, 0, 5124, 1002, 1, 0, 0, 0, 5125, 5127, 5, 36, 0, 0, 5126, 5128, 3, 1013, 506, 0, 5127, 5126, 1, 0, 0, 0, 5128, 5129, 1, 0, 0, 0, 5129, 5127, 1, 0, 0, 0, 5129, 5130, 1, 0, 0, 0, 5130, 1004, 1, 0, 0, 0, 5131, 5135, 3, 1011, 505, 0, 5132, 5134, 3, 1013, 506, 0, 5133, 5132, 1, 0, 0, 0, 5134, 5137, 1, 0, 0, 0, 5135, 5133, 1, 0, 0, 0, 5135, 5136, 1, 0, 0, 0, 5136, 1006, 1, 0, 0, 0, 5137, 5135, 1, 0, 0, 0, 5138, 5146, 3, 1011, 505, 0, 5139, 5141, 3, 1013, 506, 0, 5140, 5139, 1, 0, 0, 0, 5141, 5144, 1, 0, 0, 0, 5142, 5140, 1, 0, 0, 0, 5142, 5143, 1, 0, 0, 0, 5143, 5145, 1, 0, 0, 0, 5144, 5142, 1, 0, 0, 0, 5145, 5147, 5, 45, 0, 0, 5146, 5142, 1, 0, 0, 0, 5147, 5148, 1, 0, 0, 0, 5148, 5146, 1, 0, 0, 0, 5148, 5149, 1, 0, 0, 0, 5149, 5153, 1, 0, 0, 0, 5150, 5152, 3, 1013, 506, 0, 5151, 5150, 1, 0, 0, 0, 5152, 5155, 1, 0, 0, 0, 5153, 5151, 1, 0, 0, 0, 5153, 5154, 1, 0, 0, 0, 5154, 1008, 1, 0, 0, 0, 5155, 5153, 1, 0, 0, 0, 5156, 5160, 5, 34, 0, 0, 5157, 5159, 8, 5, 0, 0, 5158, 5157, 1, 0, 0, 0, 5159, 5162, 1, 0, 0, 0, 5160, 5158, 1, 0, 0, 0, 5160, 5161, 1, 0, 0, 0, 5161, 5163, 1, 0, 0, 0, 5162, 5160, 1, 0, 0, 0, 5163, 5173, 5, 34, 0, 0, 5164, 5168, 5, 96, 0, 0, 5165, 5167, 8, 6, 0, 0, 5166, 5165, 1, 0, 0, 0, 5167, 5170, 1, 0, 0, 0, 5168, 5166, 1, 0, 0, 0, 5168, 5169, 1, 0, 0, 0, 5169, 5171, 1, 0, 0, 0, 5170, 5168, 1, 0, 0, 0, 5171, 5173, 5, 96, 0, 0, 5172, 5156, 1, 0, 0, 0, 5172, 5164, 1, 0, 0, 0, 5173, 1010, 1, 0, 0, 0, 5174, 5175, 7, 7, 0, 0, 5175, 1012, 1, 0, 0, 0, 5176, 5177, 7, 8, 0, 0, 5177, 1014, 1, 0, 0, 0, 5178, 5179, 7, 9, 0, 0, 5179, 1016, 1, 0, 0, 0, 5180, 5181, 7, 10, 0, 0, 5181, 1018, 1, 0, 0, 0, 5182, 5183, 7, 11, 0, 0, 5183, 1020, 1, 0, 0, 0, 5184, 5185, 7, 12, 0, 0, 5185, 1022, 1, 0, 0, 0, 5186, 5187, 7, 13, 0, 0, 5187, 1024, 1, 0, 0, 0, 5188, 5189, 7, 3, 0, 0, 5189, 1026, 1, 0, 0, 0, 5190, 5191, 7, 14, 0, 0, 5191, 1028, 1, 0, 0, 0, 5192, 5193, 7, 15, 0, 0, 5193, 1030, 1, 0, 0, 0, 5194, 5195, 7, 16, 0, 0, 5195, 1032, 1, 0, 0, 0, 5196, 5197, 7, 17, 0, 0, 5197, 1034, 1, 0, 0, 0, 5198, 5199, 7, 18, 0, 0, 5199, 1036, 1, 0, 0, 0, 5200, 5201, 7, 19, 0, 0, 5201, 1038, 1, 0, 0, 0, 5202, 5203, 7, 20, 0, 0, 5203, 1040, 1, 0, 0, 0, 5204, 5205, 7, 21, 0, 0, 5205, 1042, 1, 0, 0, 0, 5206, 5207, 7, 22, 0, 0, 5207, 1044, 1, 0, 0, 0, 5208, 5209, 7, 23, 0, 0, 5209, 1046, 1, 0, 0, 0, 5210, 5211, 7, 24, 0, 0, 5211, 1048, 1, 0, 0, 0, 5212, 5213, 7, 25, 0, 0, 5213, 1050, 1, 0, 0, 0, 5214, 5215, 7, 26, 0, 0, 5215, 1052, 1, 0, 0, 0, 5216, 5217, 7, 27, 0, 0, 5217, 1054, 1, 0, 0, 0, 5218, 5219, 7, 28, 0, 0, 5219, 1056, 1, 0, 0, 0, 5220, 5221, 7, 29, 0, 0, 5221, 1058, 1, 0, 0, 0, 5222, 5223, 7, 30, 0, 0, 5223, 1060, 1, 0, 0, 0, 5224, 5225, 7, 31, 0, 0, 5225, 1062, 1, 0, 0, 0, 5226, 5227, 7, 32, 0, 0, 5227, 1064, 1, 0, 0, 0, 5228, 5229, 7, 33, 0, 0, 5229, 1066, 1, 0, 0, 0, 5230, 5231, 7, 34, 0, 0, 5231, 1068, 1, 0, 0, 0, 46, 0, 1072, 1083, 1095, 1109, 1119, 1127, 1139, 1152, 1167, 1180, 1192, 1222, 1235, 1249, 1257, 1312, 1323, 1331, 1340, 1404, 1415, 1422, 1429, 1487, 1777, 4995, 5067, 5079, 5081, 5092, 5099, 5104, 5110, 5112, 5116, 5121, 5123, 5129, 5135, 5142, 5148, 5153, 5160, 5168, 5172, 1, 6, 0, 0] \ No newline at end of file diff --git a/mdl/grammar/parser/MDLLexer.tokens b/mdl/grammar/parser/MDLLexer.tokens index 6588b47..a7624a5 100644 --- a/mdl/grammar/parser/MDLLexer.tokens +++ b/mdl/grammar/parser/MDLLexer.tokens @@ -302,209 +302,230 @@ PATTERN=301 EXPRESSION=302 XPATH=303 CONSTRAINT=304 -REST=305 -SERVICE=306 -SERVICES=307 -ODATA=308 -BASE=309 -AUTH=310 -AUTHENTICATION=311 -BASIC=312 -NOTHING=313 -OAUTH=314 -OPERATION=315 -METHOD=316 -PATH=317 -TIMEOUT=318 -BODY=319 -RESPONSE=320 -REQUEST=321 -JSON=322 -XML=323 -STATUS=324 -VERSION=325 -GET=326 -POST=327 -PUT=328 -PATCH=329 -API=330 -CLIENT=331 -CLIENTS=332 -PUBLISH=333 -EXPOSE=334 -NAMESPACE_KW=335 -SESSION=336 -GUEST=337 -PAGING=338 -NOT_SUPPORTED=339 -USERNAME=340 -PASSWORD=341 -CONNECTION=342 -DATABASE=343 -QUERY=344 -MAP=345 -MAPPING=346 -IMPORT=347 -INTO=348 -BATCH=349 -LINK=350 -EXPORT=351 -GENERATE=352 -CONNECTOR=353 -EXEC=354 -TABLES=355 -VIEWS=356 -EXPOSED=357 -PARAMETER=358 -PARAMETERS=359 -HEADERS=360 -NAVIGATION=361 -MENU_KW=362 -HOMES=363 -HOME=364 -LOGIN=365 -FOUND=366 -MODULES=367 -ENTITIES=368 -ASSOCIATIONS=369 -MICROFLOWS=370 -NANOFLOWS=371 -WORKFLOWS=372 -ENUMERATIONS=373 -CONSTANTS=374 -CONNECTIONS=375 -DEFINE=376 -FRAGMENT=377 -FRAGMENTS=378 -INSERT=379 -BEFORE=380 -AFTER=381 -UPDATE=382 -REFRESH=383 -CHECK=384 -BUILD=385 -EXECUTE=386 -SCRIPT=387 -LINT=388 -RULES=389 -TEXT=390 -SARIF=391 -MESSAGE=392 -COMMENT=393 -CATALOG=394 -FORCE=395 -BACKGROUND=396 -CALLERS=397 -CALLEES=398 -REFERENCES=399 -TRANSITIVE=400 -IMPACT=401 -DEPTH=402 -STRUCTURE=403 -TYPE=404 -VALUE=405 -SINGLE=406 -MULTIPLE=407 -NONE=408 -BOTH=409 -TO=410 -OF=411 -OVER=412 -FOR=413 -REPLACE=414 -MEMBERS=415 -ATTRIBUTE_NAME=416 -FORMAT=417 -SQL=418 -WITHOUT=419 -DRY=420 -RUN=421 -WIDGETTYPE=422 -V3=423 -BUSINESS=424 -EVENT=425 -SUBSCRIBE=426 -SETTINGS=427 -CONFIGURATION=428 -SECURITY=429 -ROLE=430 -ROLES=431 -GRANT=432 -REVOKE=433 -PRODUCTION=434 -PROTOTYPE=435 -MANAGE=436 -DEMO=437 -MATRIX=438 -APPLY=439 -ACCESS=440 -LEVEL=441 -USER=442 -READ=443 -WRITE=444 -DESCRIPTION=445 -OFF=446 -USERS=447 -NOT_EQUALS=448 -LESS_THAN_OR_EQUAL=449 -GREATER_THAN_OR_EQUAL=450 -EQUALS=451 -LESS_THAN=452 -GREATER_THAN=453 -PLUS=454 -MINUS=455 -STAR=456 -SLASH=457 -PERCENT=458 -MOD=459 -DIV=460 -SEMICOLON=461 -COMMA=462 -DOT=463 -LPAREN=464 -RPAREN=465 -LBRACE=466 -RBRACE=467 -LBRACKET=468 -RBRACKET=469 -COLON=470 -AT=471 -PIPE=472 -DOUBLE_COLON=473 -ARROW=474 -QUESTION=475 -HASH=476 -MENDIX_TOKEN=477 -STRING_LITERAL=478 -DOLLAR_STRING=479 -NUMBER_LITERAL=480 -VARIABLE=481 -IDENTIFIER=482 -HYPHENATED_ID=483 -QUOTED_IDENTIFIER=484 -'<='=449 -'>='=450 -'='=451 -'<'=452 -'>'=453 -'+'=454 -'-'=455 -'*'=456 -'/'=457 -'%'=458 -';'=461 -','=462 -'.'=463 -'('=464 -')'=465 -'{'=466 -'}'=467 -'['=468 -']'=469 -':'=470 -'@'=471 -'|'=472 -'::'=473 -'->'=474 -'?'=475 -'#'=476 +CALCULATED=305 +REST=306 +SERVICE=307 +SERVICES=308 +ODATA=309 +BASE=310 +AUTH=311 +AUTHENTICATION=312 +BASIC=313 +NOTHING=314 +OAUTH=315 +OPERATION=316 +METHOD=317 +PATH=318 +TIMEOUT=319 +BODY=320 +RESPONSE=321 +REQUEST=322 +JSON=323 +XML=324 +STATUS=325 +VERSION=326 +GET=327 +POST=328 +PUT=329 +PATCH=330 +API=331 +CLIENT=332 +CLIENTS=333 +PUBLISH=334 +EXPOSE=335 +NAMESPACE_KW=336 +SESSION=337 +GUEST=338 +PAGING=339 +NOT_SUPPORTED=340 +USERNAME=341 +PASSWORD=342 +CONNECTION=343 +DATABASE=344 +QUERY=345 +MAP=346 +MAPPING=347 +IMPORT=348 +INTO=349 +BATCH=350 +LINK=351 +EXPORT=352 +GENERATE=353 +CONNECTOR=354 +EXEC=355 +TABLES=356 +VIEWS=357 +EXPOSED=358 +PARAMETER=359 +PARAMETERS=360 +HEADERS=361 +NAVIGATION=362 +MENU_KW=363 +HOMES=364 +HOME=365 +LOGIN=366 +FOUND=367 +MODULES=368 +ENTITIES=369 +ASSOCIATIONS=370 +MICROFLOWS=371 +NANOFLOWS=372 +WORKFLOWS=373 +ENUMERATIONS=374 +CONSTANTS=375 +CONNECTIONS=376 +DEFINE=377 +FRAGMENT=378 +FRAGMENTS=379 +INSERT=380 +BEFORE=381 +AFTER=382 +UPDATE=383 +REFRESH=384 +CHECK=385 +BUILD=386 +EXECUTE=387 +SCRIPT=388 +LINT=389 +RULES=390 +TEXT=391 +SARIF=392 +MESSAGE=393 +COMMENT=394 +CATALOG=395 +FORCE=396 +BACKGROUND=397 +CALLERS=398 +CALLEES=399 +REFERENCES=400 +TRANSITIVE=401 +IMPACT=402 +DEPTH=403 +STRUCTURE=404 +TYPE=405 +VALUE=406 +SINGLE=407 +MULTIPLE=408 +NONE=409 +BOTH=410 +TO=411 +OF=412 +OVER=413 +FOR=414 +REPLACE=415 +MEMBERS=416 +ATTRIBUTE_NAME=417 +FORMAT=418 +SQL=419 +WITHOUT=420 +DRY=421 +RUN=422 +WIDGETTYPE=423 +V3=424 +BUSINESS=425 +EVENT=426 +SUBSCRIBE=427 +SETTINGS=428 +CONFIGURATION=429 +SECURITY=430 +ROLE=431 +ROLES=432 +GRANT=433 +REVOKE=434 +PRODUCTION=435 +PROTOTYPE=436 +MANAGE=437 +DEMO=438 +MATRIX=439 +APPLY=440 +ACCESS=441 +LEVEL=442 +USER=443 +TASK=444 +DECISION=445 +SPLIT=446 +OUTCOMES=447 +TARGETING=448 +NOTIFICATION=449 +TIMER=450 +JUMP=451 +DUE=452 +OVERVIEW=453 +DATE=454 +PARALLEL=455 +WAIT=456 +ANNOTATION=457 +BOUNDARY=458 +INTERRUPTING=459 +NON=460 +MULTI=461 +BY=462 +READ=463 +WRITE=464 +DESCRIPTION=465 +DISPLAY=466 +OFF=467 +USERS=468 +NOT_EQUALS=469 +LESS_THAN_OR_EQUAL=470 +GREATER_THAN_OR_EQUAL=471 +EQUALS=472 +LESS_THAN=473 +GREATER_THAN=474 +PLUS=475 +MINUS=476 +STAR=477 +SLASH=478 +PERCENT=479 +MOD=480 +DIV=481 +SEMICOLON=482 +COMMA=483 +DOT=484 +LPAREN=485 +RPAREN=486 +LBRACE=487 +RBRACE=488 +LBRACKET=489 +RBRACKET=490 +COLON=491 +AT=492 +PIPE=493 +DOUBLE_COLON=494 +ARROW=495 +QUESTION=496 +HASH=497 +MENDIX_TOKEN=498 +STRING_LITERAL=499 +DOLLAR_STRING=500 +NUMBER_LITERAL=501 +VARIABLE=502 +IDENTIFIER=503 +HYPHENATED_ID=504 +QUOTED_IDENTIFIER=505 +'<='=470 +'>='=471 +'='=472 +'<'=473 +'>'=474 +'+'=475 +'-'=476 +'*'=477 +'/'=478 +'%'=479 +';'=482 +','=483 +'.'=484 +'('=485 +')'=486 +'{'=487 +'}'=488 +'['=489 +']'=490 +':'=491 +'@'=492 +'|'=493 +'::'=494 +'->'=495 +'?'=496 +'#'=497 diff --git a/mdl/grammar/parser/MDLParser.interp b/mdl/grammar/parser/MDLParser.interp index 7692df3..489f6f9 100644 --- a/mdl/grammar/parser/MDLParser.interp +++ b/mdl/grammar/parser/MDLParser.interp @@ -448,6 +448,27 @@ 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 '<=' '>=' '=' @@ -791,6 +812,7 @@ PATTERN EXPRESSION XPATH CONSTRAINT +CALCULATED REST SERVICE SERVICES @@ -929,9 +951,29 @@ APPLY ACCESS LEVEL USER +TASK +DECISION +SPLIT +OUTCOMES +TARGETING +NOTIFICATION +TIMER +JUMP +DUE +OVERVIEW +DATE +PARALLEL +WAIT +ANNOTATION +BOUNDARY +INTERRUPTING +NON +MULTI +BY READ WRITE DESCRIPTION +DISPLAY OFF USERS NOT_EQUALS @@ -1004,6 +1046,8 @@ grantMicroflowAccessStatement revokeMicroflowAccessStatement grantPageAccessStatement revokePageAccessStatement +grantWorkflowAccessStatement +revokeWorkflowAccessStatement grantODataServiceAccessStatement revokeODataServiceAccessStatement alterProjectSecurityStatement @@ -1219,6 +1263,23 @@ odataHeaderEntry createBusinessEventServiceStatement businessEventMessageDef businessEventAttrDef +createWorkflowStatement +workflowBody +workflowActivityStmt +workflowUserTaskStmt +workflowBoundaryEventClause +workflowUserTaskOutcome +workflowCallMicroflowStmt +workflowParameterMapping +workflowCallWorkflowStmt +workflowDecisionStmt +workflowConditionOutcome +workflowParallelSplitStmt +workflowParallelPath +workflowJumpToStmt +workflowWaitForTimerStmt +workflowWaitForNotificationStmt +workflowAnnotationStmt alterSettingsClause settingsSection settingsAssignment @@ -1312,4 +1373,4 @@ keyword atn: -[4, 1, 484, 5269, 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, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 1, 0, 5, 0, 674, 8, 0, 10, 0, 12, 0, 677, 9, 0, 1, 0, 1, 0, 1, 1, 3, 1, 682, 8, 1, 1, 1, 1, 1, 1, 1, 3, 1, 687, 8, 1, 1, 1, 3, 1, 690, 8, 1, 1, 1, 3, 1, 693, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 702, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 710, 8, 3, 10, 3, 12, 3, 713, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 719, 8, 3, 10, 3, 12, 3, 722, 9, 3, 1, 3, 1, 3, 1, 3, 3, 3, 727, 8, 3, 3, 3, 729, 8, 3, 1, 3, 1, 3, 3, 3, 733, 8, 3, 1, 4, 3, 4, 736, 8, 4, 1, 4, 5, 4, 739, 8, 4, 10, 4, 12, 4, 742, 9, 4, 1, 4, 1, 4, 1, 4, 3, 4, 747, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 768, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 774, 8, 5, 11, 5, 12, 5, 775, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 782, 8, 5, 11, 5, 12, 5, 783, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 790, 8, 5, 11, 5, 12, 5, 791, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 798, 8, 5, 11, 5, 12, 5, 799, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 810, 8, 5, 10, 5, 12, 5, 813, 9, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 823, 8, 5, 10, 5, 12, 5, 826, 9, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 836, 8, 5, 11, 5, 12, 5, 837, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 848, 8, 5, 11, 5, 12, 5, 849, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 859, 8, 5, 11, 5, 12, 5, 860, 1, 5, 1, 5, 3, 5, 865, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 5, 6, 871, 8, 6, 10, 6, 12, 6, 874, 9, 6, 1, 6, 1, 6, 1, 6, 3, 6, 879, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 896, 8, 7, 1, 8, 1, 8, 3, 8, 900, 8, 8, 1, 8, 1, 8, 3, 8, 904, 8, 8, 1, 8, 1, 8, 3, 8, 908, 8, 8, 1, 8, 1, 8, 3, 8, 912, 8, 8, 3, 8, 914, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 926, 8, 9, 10, 9, 12, 9, 929, 9, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 937, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 946, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 962, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 969, 8, 12, 10, 12, 12, 12, 972, 9, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 986, 8, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 998, 8, 14, 10, 14, 12, 14, 1001, 9, 14, 1, 14, 3, 14, 1004, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1013, 8, 15, 1, 15, 3, 15, 1016, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1022, 8, 15, 10, 15, 12, 15, 1025, 9, 15, 1, 15, 1, 15, 3, 15, 1029, 8, 15, 3, 15, 1031, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1086, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1099, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1110, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1119, 8, 18, 3, 18, 1121, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1132, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1138, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1146, 8, 18, 3, 18, 1148, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1167, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 1175, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 1192, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 1216, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1232, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1300, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 1312, 8, 34, 10, 34, 12, 34, 1315, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1328, 8, 36, 1, 37, 1, 37, 1, 37, 5, 37, 1333, 8, 37, 10, 37, 12, 37, 1336, 9, 37, 1, 38, 1, 38, 1, 38, 5, 38, 1341, 8, 38, 10, 38, 12, 38, 1344, 9, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 5, 39, 1355, 8, 39, 10, 39, 12, 39, 1358, 9, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 5, 39, 1368, 8, 39, 10, 39, 12, 39, 1371, 9, 39, 1, 39, 3, 39, 1374, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1380, 8, 40, 1, 40, 3, 40, 1383, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1389, 8, 40, 1, 40, 3, 40, 1392, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1398, 8, 40, 1, 40, 1, 40, 3, 40, 1402, 8, 40, 1, 40, 1, 40, 3, 40, 1406, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1412, 8, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1417, 8, 40, 1, 40, 3, 40, 1420, 8, 40, 3, 40, 1422, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 1428, 8, 41, 1, 42, 1, 42, 3, 42, 1432, 8, 42, 1, 42, 1, 42, 3, 42, 1436, 8, 42, 1, 42, 3, 42, 1439, 8, 42, 1, 43, 1, 43, 3, 43, 1443, 8, 43, 1, 43, 5, 43, 1446, 8, 43, 10, 43, 12, 43, 1449, 9, 43, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1455, 8, 44, 1, 45, 1, 45, 1, 45, 5, 45, 1460, 8, 45, 10, 45, 12, 45, 1463, 9, 45, 1, 46, 3, 46, 1466, 8, 46, 1, 46, 5, 46, 1469, 8, 46, 10, 46, 12, 46, 1472, 9, 46, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 1478, 8, 46, 10, 46, 12, 46, 1481, 9, 46, 1, 47, 1, 47, 1, 47, 3, 47, 1486, 8, 47, 1, 48, 1, 48, 1, 48, 3, 48, 1491, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1497, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1502, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1507, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1512, 8, 48, 3, 48, 1514, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1520, 8, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1552, 8, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1560, 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1581, 8, 51, 1, 52, 3, 52, 1584, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 5, 53, 1593, 8, 53, 10, 53, 12, 53, 1596, 9, 53, 1, 54, 1, 54, 3, 54, 1600, 8, 54, 1, 55, 1, 55, 1, 55, 3, 55, 1605, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1614, 8, 56, 1, 57, 4, 57, 1617, 8, 57, 11, 57, 12, 57, 1618, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1631, 8, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1658, 8, 60, 10, 60, 12, 60, 1661, 9, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1668, 8, 60, 10, 60, 12, 60, 1671, 9, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1691, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1705, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1712, 8, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1725, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1732, 8, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1740, 8, 63, 1, 64, 1, 64, 1, 64, 3, 64, 1745, 8, 64, 1, 65, 4, 65, 1748, 8, 65, 11, 65, 12, 65, 1749, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1756, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1764, 8, 67, 1, 68, 1, 68, 1, 68, 5, 68, 1769, 8, 68, 10, 68, 12, 68, 1772, 9, 68, 1, 69, 3, 69, 1775, 8, 69, 1, 69, 1, 69, 3, 69, 1779, 8, 69, 1, 69, 3, 69, 1782, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1799, 8, 70, 1, 71, 4, 71, 1802, 8, 71, 11, 71, 12, 71, 1803, 1, 72, 1, 72, 1, 72, 1, 73, 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, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 1843, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1858, 8, 75, 1, 76, 1, 76, 1, 76, 5, 76, 1863, 8, 76, 10, 76, 12, 76, 1866, 9, 76, 1, 77, 1, 77, 1, 77, 5, 77, 1871, 8, 77, 10, 77, 12, 77, 1874, 9, 77, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1880, 8, 78, 1, 78, 1, 78, 3, 78, 1884, 8, 78, 1, 78, 3, 78, 1887, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1893, 8, 78, 1, 78, 3, 78, 1896, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1903, 8, 79, 1, 79, 1, 79, 3, 79, 1907, 8, 79, 1, 79, 3, 79, 1910, 8, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1915, 8, 79, 1, 80, 1, 80, 1, 80, 5, 80, 1920, 8, 80, 10, 80, 12, 80, 1923, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1929, 8, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 5, 84, 1943, 8, 84, 10, 84, 12, 84, 1946, 9, 84, 1, 85, 1, 85, 3, 85, 1950, 8, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 3, 86, 1958, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1964, 8, 87, 1, 88, 4, 88, 1967, 8, 88, 11, 88, 12, 88, 1968, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1975, 8, 89, 1, 90, 5, 90, 1978, 8, 90, 10, 90, 12, 90, 1981, 9, 90, 1, 91, 5, 91, 1984, 8, 91, 10, 91, 12, 91, 1987, 9, 91, 1, 91, 1, 91, 3, 91, 1991, 8, 91, 1, 91, 5, 91, 1994, 8, 91, 10, 91, 12, 91, 1997, 9, 91, 1, 91, 1, 91, 3, 91, 2001, 8, 91, 1, 91, 5, 91, 2004, 8, 91, 10, 91, 12, 91, 2007, 9, 91, 1, 91, 1, 91, 3, 91, 2011, 8, 91, 1, 91, 5, 91, 2014, 8, 91, 10, 91, 12, 91, 2017, 9, 91, 1, 91, 1, 91, 3, 91, 2021, 8, 91, 1, 91, 5, 91, 2024, 8, 91, 10, 91, 12, 91, 2027, 9, 91, 1, 91, 1, 91, 3, 91, 2031, 8, 91, 1, 91, 5, 91, 2034, 8, 91, 10, 91, 12, 91, 2037, 9, 91, 1, 91, 1, 91, 3, 91, 2041, 8, 91, 1, 91, 5, 91, 2044, 8, 91, 10, 91, 12, 91, 2047, 9, 91, 1, 91, 1, 91, 3, 91, 2051, 8, 91, 1, 91, 5, 91, 2054, 8, 91, 10, 91, 12, 91, 2057, 9, 91, 1, 91, 1, 91, 3, 91, 2061, 8, 91, 1, 91, 5, 91, 2064, 8, 91, 10, 91, 12, 91, 2067, 9, 91, 1, 91, 1, 91, 3, 91, 2071, 8, 91, 1, 91, 5, 91, 2074, 8, 91, 10, 91, 12, 91, 2077, 9, 91, 1, 91, 1, 91, 3, 91, 2081, 8, 91, 1, 91, 5, 91, 2084, 8, 91, 10, 91, 12, 91, 2087, 9, 91, 1, 91, 1, 91, 3, 91, 2091, 8, 91, 1, 91, 5, 91, 2094, 8, 91, 10, 91, 12, 91, 2097, 9, 91, 1, 91, 1, 91, 3, 91, 2101, 8, 91, 1, 91, 5, 91, 2104, 8, 91, 10, 91, 12, 91, 2107, 9, 91, 1, 91, 1, 91, 3, 91, 2111, 8, 91, 1, 91, 5, 91, 2114, 8, 91, 10, 91, 12, 91, 2117, 9, 91, 1, 91, 1, 91, 3, 91, 2121, 8, 91, 1, 91, 5, 91, 2124, 8, 91, 10, 91, 12, 91, 2127, 9, 91, 1, 91, 1, 91, 3, 91, 2131, 8, 91, 1, 91, 5, 91, 2134, 8, 91, 10, 91, 12, 91, 2137, 9, 91, 1, 91, 1, 91, 3, 91, 2141, 8, 91, 1, 91, 5, 91, 2144, 8, 91, 10, 91, 12, 91, 2147, 9, 91, 1, 91, 1, 91, 3, 91, 2151, 8, 91, 1, 91, 5, 91, 2154, 8, 91, 10, 91, 12, 91, 2157, 9, 91, 1, 91, 1, 91, 3, 91, 2161, 8, 91, 1, 91, 5, 91, 2164, 8, 91, 10, 91, 12, 91, 2167, 9, 91, 1, 91, 1, 91, 3, 91, 2171, 8, 91, 1, 91, 5, 91, 2174, 8, 91, 10, 91, 12, 91, 2177, 9, 91, 1, 91, 1, 91, 3, 91, 2181, 8, 91, 1, 91, 5, 91, 2184, 8, 91, 10, 91, 12, 91, 2187, 9, 91, 1, 91, 1, 91, 3, 91, 2191, 8, 91, 1, 91, 5, 91, 2194, 8, 91, 10, 91, 12, 91, 2197, 9, 91, 1, 91, 1, 91, 3, 91, 2201, 8, 91, 1, 91, 5, 91, 2204, 8, 91, 10, 91, 12, 91, 2207, 9, 91, 1, 91, 1, 91, 3, 91, 2211, 8, 91, 1, 91, 5, 91, 2214, 8, 91, 10, 91, 12, 91, 2217, 9, 91, 1, 91, 1, 91, 3, 91, 2221, 8, 91, 1, 91, 5, 91, 2224, 8, 91, 10, 91, 12, 91, 2227, 9, 91, 1, 91, 1, 91, 3, 91, 2231, 8, 91, 1, 91, 5, 91, 2234, 8, 91, 10, 91, 12, 91, 2237, 9, 91, 1, 91, 1, 91, 3, 91, 2241, 8, 91, 1, 91, 5, 91, 2244, 8, 91, 10, 91, 12, 91, 2247, 9, 91, 1, 91, 1, 91, 3, 91, 2251, 8, 91, 1, 91, 5, 91, 2254, 8, 91, 10, 91, 12, 91, 2257, 9, 91, 1, 91, 1, 91, 3, 91, 2261, 8, 91, 1, 91, 5, 91, 2264, 8, 91, 10, 91, 12, 91, 2267, 9, 91, 1, 91, 1, 91, 3, 91, 2271, 8, 91, 1, 91, 5, 91, 2274, 8, 91, 10, 91, 12, 91, 2277, 9, 91, 1, 91, 1, 91, 3, 91, 2281, 8, 91, 1, 91, 5, 91, 2284, 8, 91, 10, 91, 12, 91, 2287, 9, 91, 1, 91, 1, 91, 3, 91, 2291, 8, 91, 1, 91, 5, 91, 2294, 8, 91, 10, 91, 12, 91, 2297, 9, 91, 1, 91, 1, 91, 3, 91, 2301, 8, 91, 3, 91, 2303, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2310, 8, 92, 1, 93, 1, 93, 1, 93, 3, 93, 2315, 8, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 3, 94, 2322, 8, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2328, 8, 94, 1, 94, 3, 94, 2331, 8, 94, 1, 94, 3, 94, 2334, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 2340, 8, 95, 1, 95, 3, 95, 2343, 8, 95, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2349, 8, 96, 4, 96, 2351, 8, 96, 11, 96, 12, 96, 2352, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2359, 8, 97, 1, 97, 3, 97, 2362, 8, 97, 1, 97, 3, 97, 2365, 8, 97, 1, 98, 1, 98, 1, 98, 3, 98, 2370, 8, 98, 1, 99, 1, 99, 1, 99, 3, 99, 2375, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2384, 8, 100, 3, 100, 2386, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2392, 8, 100, 10, 100, 12, 100, 2395, 9, 100, 3, 100, 2397, 8, 100, 1, 100, 1, 100, 3, 100, 2401, 8, 100, 1, 100, 1, 100, 3, 100, 2405, 8, 100, 1, 100, 3, 100, 2408, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2417, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2439, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 2450, 8, 103, 10, 103, 12, 103, 2453, 9, 103, 1, 103, 1, 103, 3, 103, 2457, 8, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2467, 8, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 3, 105, 2477, 8, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2482, 8, 105, 1, 106, 1, 106, 1, 107, 1, 107, 1, 108, 1, 108, 3, 108, 2490, 8, 108, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 3, 110, 2497, 8, 110, 1, 110, 1, 110, 3, 110, 2501, 8, 110, 1, 110, 1, 110, 3, 110, 2505, 8, 110, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 5, 112, 2514, 8, 112, 10, 112, 12, 112, 2517, 9, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2523, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 115, 1, 115, 1, 116, 1, 116, 3, 116, 2537, 8, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2544, 8, 116, 1, 116, 1, 116, 3, 116, 2548, 8, 116, 1, 117, 1, 117, 3, 117, 2552, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2560, 8, 117, 1, 117, 1, 117, 3, 117, 2564, 8, 117, 1, 118, 1, 118, 3, 118, 2568, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2578, 8, 118, 3, 118, 2580, 8, 118, 1, 118, 1, 118, 3, 118, 2584, 8, 118, 1, 118, 3, 118, 2587, 8, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2592, 8, 118, 1, 118, 3, 118, 2595, 8, 118, 1, 118, 3, 118, 2598, 8, 118, 1, 119, 1, 119, 3, 119, 2602, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2610, 8, 119, 1, 119, 1, 119, 3, 119, 2614, 8, 119, 1, 120, 1, 120, 1, 120, 5, 120, 2619, 8, 120, 10, 120, 12, 120, 2622, 9, 120, 1, 121, 1, 121, 3, 121, 2626, 8, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2636, 8, 122, 1, 122, 3, 122, 2639, 8, 122, 1, 122, 1, 122, 3, 122, 2643, 8, 122, 1, 122, 1, 122, 3, 122, 2647, 8, 122, 1, 123, 1, 123, 1, 123, 5, 123, 2652, 8, 123, 10, 123, 12, 123, 2655, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2661, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2667, 8, 124, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2681, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2688, 8, 127, 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, 129, 3, 129, 2703, 8, 129, 1, 130, 1, 130, 3, 130, 2707, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2714, 8, 130, 1, 130, 5, 130, 2717, 8, 130, 10, 130, 12, 130, 2720, 9, 130, 1, 130, 3, 130, 2723, 8, 130, 1, 130, 3, 130, 2726, 8, 130, 1, 130, 3, 130, 2729, 8, 130, 1, 130, 1, 130, 3, 130, 2733, 8, 130, 1, 131, 1, 131, 1, 132, 1, 132, 3, 132, 2739, 8, 132, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 3, 136, 2757, 8, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2762, 8, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2770, 8, 136, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 2789, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 2854, 8, 140, 1, 141, 1, 141, 1, 141, 5, 141, 2859, 8, 141, 10, 141, 12, 141, 2862, 9, 141, 1, 142, 1, 142, 3, 142, 2866, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 2896, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 5, 148, 2917, 8, 148, 10, 148, 12, 148, 2920, 9, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 2930, 8, 150, 1, 151, 1, 151, 1, 151, 5, 151, 2935, 8, 151, 10, 151, 12, 151, 2938, 9, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 3, 154, 2954, 8, 154, 1, 154, 3, 154, 2957, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 4, 155, 2964, 8, 155, 11, 155, 12, 155, 2965, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 5, 157, 2974, 8, 157, 10, 157, 12, 157, 2977, 9, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 5, 159, 2986, 8, 159, 10, 159, 12, 159, 2989, 9, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 5, 161, 2998, 8, 161, 10, 161, 12, 161, 3001, 9, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 3, 163, 3011, 8, 163, 1, 163, 3, 163, 3014, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 5, 166, 3025, 8, 166, 10, 166, 12, 166, 3028, 9, 166, 1, 167, 1, 167, 1, 167, 5, 167, 3033, 8, 167, 10, 167, 12, 167, 3036, 9, 167, 1, 168, 1, 168, 1, 168, 3, 168, 3041, 8, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 3047, 8, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3055, 8, 170, 1, 171, 1, 171, 1, 171, 5, 171, 3060, 8, 171, 10, 171, 12, 171, 3063, 9, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 3070, 8, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 3077, 8, 173, 1, 174, 1, 174, 1, 174, 5, 174, 3082, 8, 174, 10, 174, 12, 174, 3085, 9, 174, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 5, 176, 3094, 8, 176, 10, 176, 12, 176, 3097, 9, 176, 3, 176, 3099, 8, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3109, 8, 178, 10, 178, 12, 178, 3112, 9, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 3135, 8, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 3143, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 5, 180, 3149, 8, 180, 10, 180, 12, 180, 3152, 9, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3171, 8, 181, 1, 182, 1, 182, 5, 182, 3175, 8, 182, 10, 182, 12, 182, 3178, 9, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 3185, 8, 183, 1, 184, 1, 184, 1, 184, 3, 184, 3190, 8, 184, 1, 184, 3, 184, 3193, 8, 184, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 5, 186, 3201, 8, 186, 10, 186, 12, 186, 3204, 9, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 3283, 8, 187, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 5, 189, 3291, 8, 189, 10, 189, 12, 189, 3294, 9, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 3, 190, 3301, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 5, 190, 3309, 8, 190, 10, 190, 12, 190, 3312, 9, 190, 1, 190, 3, 190, 3315, 8, 190, 3, 190, 3317, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 5, 190, 3323, 8, 190, 10, 190, 12, 190, 3326, 9, 190, 3, 190, 3328, 8, 190, 1, 190, 1, 190, 1, 190, 3, 190, 3333, 8, 190, 1, 190, 1, 190, 1, 190, 3, 190, 3338, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 3344, 8, 190, 1, 191, 1, 191, 3, 191, 3348, 8, 191, 1, 191, 1, 191, 3, 191, 3352, 8, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3358, 8, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3364, 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3369, 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3374, 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3379, 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3384, 8, 191, 1, 192, 1, 192, 1, 192, 1, 192, 5, 192, 3390, 8, 192, 10, 192, 12, 192, 3393, 9, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3403, 8, 193, 1, 194, 1, 194, 1, 194, 3, 194, 3408, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 3414, 8, 194, 5, 194, 3416, 8, 194, 10, 194, 12, 194, 3419, 9, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 3427, 8, 195, 3, 195, 3429, 8, 195, 3, 195, 3431, 8, 195, 1, 196, 1, 196, 1, 196, 1, 196, 5, 196, 3437, 8, 196, 10, 196, 12, 196, 3440, 9, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 5, 202, 3473, 8, 202, 10, 202, 12, 202, 3476, 9, 202, 3, 202, 3478, 8, 202, 1, 202, 3, 202, 3481, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 5, 203, 3487, 8, 203, 10, 203, 12, 203, 3490, 9, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 3496, 8, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 3507, 8, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 3, 206, 3516, 8, 206, 1, 206, 1, 206, 5, 206, 3520, 8, 206, 10, 206, 12, 206, 3523, 9, 206, 1, 206, 1, 206, 1, 207, 4, 207, 3528, 8, 207, 11, 207, 12, 207, 3529, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 3, 209, 3539, 8, 209, 1, 210, 1, 210, 1, 210, 1, 210, 4, 210, 3545, 8, 210, 11, 210, 12, 210, 3546, 1, 210, 1, 210, 5, 210, 3551, 8, 210, 10, 210, 12, 210, 3554, 9, 210, 1, 210, 3, 210, 3557, 8, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 3566, 8, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 3578, 8, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 3584, 8, 211, 3, 211, 3586, 8, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 3599, 8, 212, 5, 212, 3601, 8, 212, 10, 212, 12, 212, 3604, 9, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 5, 212, 3613, 8, 212, 10, 212, 12, 212, 3616, 9, 212, 1, 212, 1, 212, 3, 212, 3620, 8, 212, 3, 212, 3622, 8, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 3637, 8, 214, 1, 215, 4, 215, 3640, 8, 215, 11, 215, 12, 215, 3641, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 5, 217, 3653, 8, 217, 10, 217, 12, 217, 3656, 9, 217, 1, 217, 1, 217, 1, 218, 4, 218, 3661, 8, 218, 11, 218, 12, 218, 3662, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, 3674, 8, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 3, 220, 3684, 8, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 3693, 8, 221, 1, 222, 1, 222, 1, 223, 4, 223, 3698, 8, 223, 11, 223, 12, 223, 3699, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 3710, 8, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 3721, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 5, 228, 3738, 8, 228, 10, 228, 12, 228, 3741, 9, 228, 1, 228, 1, 228, 3, 228, 3745, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 5, 229, 3754, 8, 229, 10, 229, 12, 229, 3757, 9, 229, 1, 229, 1, 229, 3, 229, 3761, 8, 229, 1, 229, 1, 229, 5, 229, 3765, 8, 229, 10, 229, 12, 229, 3768, 9, 229, 1, 229, 3, 229, 3771, 8, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 3, 230, 3779, 8, 230, 1, 230, 3, 230, 3782, 8, 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, 5, 233, 3796, 8, 233, 10, 233, 12, 233, 3799, 9, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 3806, 8, 234, 1, 234, 3, 234, 3809, 8, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 3, 235, 3816, 8, 235, 1, 235, 1, 235, 1, 235, 1, 235, 5, 235, 3822, 8, 235, 10, 235, 12, 235, 3825, 9, 235, 1, 235, 1, 235, 3, 235, 3829, 8, 235, 1, 235, 3, 235, 3832, 8, 235, 1, 235, 3, 235, 3835, 8, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 5, 236, 3843, 8, 236, 10, 236, 12, 236, 3846, 9, 236, 3, 236, 3848, 8, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 3, 237, 3855, 8, 237, 1, 237, 3, 237, 3858, 8, 237, 1, 238, 1, 238, 1, 238, 1, 238, 5, 238, 3864, 8, 238, 10, 238, 12, 238, 3867, 9, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 5, 239, 3882, 8, 239, 10, 239, 12, 239, 3885, 9, 239, 1, 239, 1, 239, 1, 239, 3, 239, 3890, 8, 239, 1, 239, 3, 239, 3893, 8, 239, 1, 240, 1, 240, 1, 240, 3, 240, 3898, 8, 240, 1, 240, 5, 240, 3901, 8, 240, 10, 240, 12, 240, 3904, 9, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 5, 241, 3911, 8, 241, 10, 241, 12, 241, 3914, 9, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 5, 243, 3930, 8, 243, 10, 243, 12, 243, 3933, 9, 243, 1, 243, 1, 243, 1, 243, 4, 243, 3938, 8, 243, 11, 243, 12, 243, 3939, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 5, 244, 3950, 8, 244, 10, 244, 12, 244, 3953, 9, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, 3959, 8, 244, 1, 244, 1, 244, 3, 244, 3963, 8, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 5, 246, 3975, 8, 246, 10, 246, 12, 246, 3978, 9, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 3987, 8, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 5, 246, 3994, 8, 246, 10, 246, 12, 246, 3997, 9, 246, 3, 246, 3999, 8, 246, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 4011, 8, 249, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 4017, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4026, 8, 251, 3, 251, 4028, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4035, 8, 251, 3, 251, 4037, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4044, 8, 251, 3, 251, 4046, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4053, 8, 251, 3, 251, 4055, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4062, 8, 251, 3, 251, 4064, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4071, 8, 251, 3, 251, 4073, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4080, 8, 251, 3, 251, 4082, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4089, 8, 251, 3, 251, 4091, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4098, 8, 251, 3, 251, 4100, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4107, 8, 251, 3, 251, 4109, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4116, 8, 251, 3, 251, 4118, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4126, 8, 251, 3, 251, 4128, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4156, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4163, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4179, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4184, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4195, 8, 251, 3, 251, 4197, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4225, 8, 251, 3, 251, 4227, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4235, 8, 251, 3, 251, 4237, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4245, 8, 251, 3, 251, 4247, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4255, 8, 251, 3, 251, 4257, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4266, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4276, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4282, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4287, 8, 251, 3, 251, 4289, 8, 251, 1, 251, 3, 251, 4292, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4301, 8, 251, 3, 251, 4303, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4312, 8, 251, 3, 251, 4314, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4322, 8, 251, 3, 251, 4324, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4336, 8, 251, 3, 251, 4338, 8, 251, 3, 251, 4340, 8, 251, 1, 252, 1, 252, 1, 252, 1, 252, 5, 252, 4346, 8, 252, 10, 252, 12, 252, 4349, 9, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4354, 8, 252, 3, 252, 4356, 8, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4361, 8, 252, 3, 252, 4363, 8, 252, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 3, 254, 4373, 8, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 3, 256, 4383, 8, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4424, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4454, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4463, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4499, 8, 257, 1, 258, 1, 258, 3, 258, 4503, 8, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 3, 258, 4511, 8, 258, 1, 258, 3, 258, 4514, 8, 258, 1, 258, 5, 258, 4517, 8, 258, 10, 258, 12, 258, 4520, 9, 258, 1, 258, 1, 258, 3, 258, 4524, 8, 258, 1, 258, 1, 258, 1, 258, 1, 258, 3, 258, 4530, 8, 258, 3, 258, 4532, 8, 258, 1, 258, 1, 258, 3, 258, 4536, 8, 258, 1, 258, 1, 258, 3, 258, 4540, 8, 258, 1, 258, 1, 258, 3, 258, 4544, 8, 258, 1, 259, 3, 259, 4547, 8, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 4554, 8, 259, 1, 259, 3, 259, 4557, 8, 259, 1, 259, 1, 259, 3, 259, 4561, 8, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 3, 261, 4568, 8, 261, 1, 261, 5, 261, 4571, 8, 261, 10, 261, 12, 261, 4574, 9, 261, 1, 262, 1, 262, 3, 262, 4578, 8, 262, 1, 262, 3, 262, 4581, 8, 262, 1, 262, 3, 262, 4584, 8, 262, 1, 262, 3, 262, 4587, 8, 262, 1, 262, 3, 262, 4590, 8, 262, 1, 262, 3, 262, 4593, 8, 262, 1, 262, 1, 262, 3, 262, 4597, 8, 262, 1, 262, 3, 262, 4600, 8, 262, 1, 262, 3, 262, 4603, 8, 262, 1, 262, 1, 262, 3, 262, 4607, 8, 262, 1, 262, 3, 262, 4610, 8, 262, 3, 262, 4612, 8, 262, 1, 263, 1, 263, 3, 263, 4616, 8, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 5, 264, 4624, 8, 264, 10, 264, 12, 264, 4627, 9, 264, 3, 264, 4629, 8, 264, 1, 265, 1, 265, 1, 265, 3, 265, 4634, 8, 265, 1, 265, 1, 265, 1, 265, 3, 265, 4639, 8, 265, 3, 265, 4641, 8, 265, 1, 266, 1, 266, 3, 266, 4645, 8, 266, 1, 267, 1, 267, 1, 267, 5, 267, 4650, 8, 267, 10, 267, 12, 267, 4653, 9, 267, 1, 268, 1, 268, 3, 268, 4657, 8, 268, 1, 268, 3, 268, 4660, 8, 268, 1, 268, 1, 268, 1, 268, 1, 268, 3, 268, 4666, 8, 268, 1, 268, 3, 268, 4669, 8, 268, 3, 268, 4671, 8, 268, 1, 269, 3, 269, 4674, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 4680, 8, 269, 1, 269, 3, 269, 4683, 8, 269, 1, 269, 1, 269, 1, 269, 3, 269, 4688, 8, 269, 1, 269, 3, 269, 4691, 8, 269, 3, 269, 4693, 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4705, 8, 270, 1, 271, 1, 271, 3, 271, 4709, 8, 271, 1, 271, 1, 271, 3, 271, 4713, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4718, 8, 271, 1, 271, 3, 271, 4721, 8, 271, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 5, 276, 4738, 8, 276, 10, 276, 12, 276, 4741, 9, 276, 1, 277, 1, 277, 3, 277, 4745, 8, 277, 1, 278, 1, 278, 1, 278, 5, 278, 4750, 8, 278, 10, 278, 12, 278, 4753, 9, 278, 1, 279, 1, 279, 1, 279, 1, 279, 3, 279, 4759, 8, 279, 1, 279, 1, 279, 1, 279, 1, 279, 3, 279, 4765, 8, 279, 3, 279, 4767, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 4785, 8, 280, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 3, 282, 4796, 8, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 3, 282, 4811, 8, 282, 3, 282, 4813, 8, 282, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 4821, 8, 284, 1, 284, 3, 284, 4824, 8, 284, 1, 284, 3, 284, 4827, 8, 284, 1, 284, 3, 284, 4830, 8, 284, 1, 284, 3, 284, 4833, 8, 284, 1, 285, 1, 285, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 3, 289, 4849, 8, 289, 1, 289, 1, 289, 3, 289, 4853, 8, 289, 1, 289, 1, 289, 1, 289, 3, 289, 4858, 8, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 4866, 8, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 3, 292, 4874, 8, 292, 1, 293, 1, 293, 1, 293, 5, 293, 4879, 8, 293, 10, 293, 12, 293, 4882, 9, 293, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 5, 297, 4922, 8, 297, 10, 297, 12, 297, 4925, 9, 297, 1, 297, 1, 297, 3, 297, 4929, 8, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 5, 297, 4936, 8, 297, 10, 297, 12, 297, 4939, 9, 297, 1, 297, 1, 297, 3, 297, 4943, 8, 297, 1, 297, 3, 297, 4946, 8, 297, 1, 297, 1, 297, 1, 297, 3, 297, 4951, 8, 297, 1, 298, 4, 298, 4954, 8, 298, 11, 298, 12, 298, 4955, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 5, 299, 4970, 8, 299, 10, 299, 12, 299, 4973, 9, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 5, 299, 4981, 8, 299, 10, 299, 12, 299, 4984, 9, 299, 1, 299, 1, 299, 3, 299, 4988, 8, 299, 1, 299, 1, 299, 3, 299, 4992, 8, 299, 1, 299, 1, 299, 3, 299, 4996, 8, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 5012, 8, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 5, 305, 5029, 8, 305, 10, 305, 12, 305, 5032, 9, 305, 1, 306, 1, 306, 1, 306, 5, 306, 5037, 8, 306, 10, 306, 12, 306, 5040, 9, 306, 1, 307, 3, 307, 5043, 8, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5057, 8, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5062, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5070, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5076, 8, 308, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 5, 310, 5083, 8, 310, 10, 310, 12, 310, 5086, 9, 310, 1, 311, 1, 311, 1, 311, 5, 311, 5091, 8, 311, 10, 311, 12, 311, 5094, 9, 311, 1, 312, 3, 312, 5097, 8, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 5121, 8, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 4, 314, 5129, 8, 314, 11, 314, 12, 314, 5130, 1, 314, 1, 314, 3, 314, 5135, 8, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 3, 317, 5151, 8, 317, 1, 317, 1, 317, 3, 317, 5155, 8, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 3, 318, 5162, 8, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 5, 320, 5171, 8, 320, 10, 320, 12, 320, 5174, 9, 320, 1, 321, 1, 321, 1, 321, 1, 321, 5, 321, 5180, 8, 321, 10, 321, 12, 321, 5183, 9, 321, 1, 321, 1, 321, 1, 321, 3, 321, 5188, 8, 321, 1, 322, 1, 322, 1, 322, 5, 322, 5193, 8, 322, 10, 322, 12, 322, 5196, 9, 322, 1, 323, 1, 323, 1, 323, 5, 323, 5201, 8, 323, 10, 323, 12, 323, 5204, 9, 323, 1, 324, 1, 324, 1, 324, 3, 324, 5209, 8, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 5216, 8, 325, 1, 326, 1, 326, 1, 326, 1, 326, 5, 326, 5222, 8, 326, 10, 326, 12, 326, 5225, 9, 326, 3, 326, 5227, 8, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 5242, 8, 329, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 5, 331, 5249, 8, 331, 10, 331, 12, 331, 5252, 9, 331, 1, 332, 1, 332, 1, 332, 1, 332, 3, 332, 5258, 8, 332, 1, 333, 1, 333, 1, 333, 3, 333, 5263, 8, 333, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 0, 0, 336, 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, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 0, 46, 2, 0, 22, 22, 414, 414, 1, 0, 33, 34, 2, 0, 30, 30, 33, 33, 2, 0, 434, 435, 446, 446, 2, 0, 92, 92, 446, 446, 2, 0, 390, 390, 418, 418, 1, 0, 93, 94, 2, 0, 12, 12, 43, 43, 2, 0, 290, 290, 409, 409, 2, 0, 39, 39, 51, 51, 2, 0, 14, 16, 53, 54, 2, 0, 457, 457, 463, 463, 3, 0, 68, 68, 133, 136, 297, 297, 2, 0, 99, 99, 326, 329, 2, 0, 478, 478, 482, 482, 1, 0, 481, 482, 1, 0, 280, 281, 6, 0, 280, 282, 448, 453, 457, 457, 461, 465, 468, 469, 477, 481, 4, 0, 126, 126, 282, 282, 291, 292, 482, 483, 10, 0, 39, 39, 146, 155, 158, 160, 162, 163, 165, 165, 167, 174, 178, 183, 192, 193, 222, 226, 246, 246, 3, 0, 126, 126, 138, 138, 482, 482, 3, 0, 250, 256, 390, 390, 482, 482, 4, 0, 133, 134, 241, 245, 290, 290, 482, 482, 2, 0, 213, 213, 480, 480, 1, 0, 406, 408, 1, 0, 478, 479, 4, 0, 193, 193, 317, 317, 319, 319, 344, 344, 2, 0, 333, 333, 426, 426, 2, 0, 372, 372, 482, 482, 7, 0, 146, 152, 158, 160, 163, 163, 167, 174, 192, 193, 222, 226, 482, 482, 2, 0, 286, 286, 451, 451, 1, 0, 83, 84, 8, 0, 141, 143, 185, 185, 190, 190, 220, 220, 308, 308, 367, 368, 370, 373, 482, 482, 2, 0, 322, 322, 390, 391, 1, 0, 482, 483, 2, 1, 457, 457, 461, 461, 1, 0, 448, 453, 1, 0, 454, 455, 2, 0, 456, 460, 470, 470, 1, 0, 257, 262, 1, 0, 271, 275, 7, 0, 121, 121, 126, 126, 138, 138, 183, 183, 271, 277, 291, 292, 482, 483, 1, 0, 291, 292, 6, 0, 48, 48, 186, 187, 215, 215, 296, 296, 393, 393, 482, 482, 36, 0, 41, 43, 48, 48, 50, 51, 53, 53, 68, 68, 114, 114, 122, 122, 133, 134, 136, 136, 162, 162, 166, 166, 186, 186, 189, 191, 194, 194, 203, 204, 211, 212, 214, 215, 218, 218, 227, 227, 242, 242, 271, 275, 297, 297, 299, 299, 324, 325, 340, 341, 361, 361, 364, 364, 384, 384, 390, 390, 392, 392, 404, 409, 417, 417, 430, 430, 434, 435, 440, 442, 445, 446, 55, 0, 8, 9, 17, 21, 23, 30, 33, 35, 38, 43, 47, 48, 50, 51, 53, 53, 55, 58, 64, 66, 68, 75, 80, 89, 92, 92, 95, 100, 102, 105, 109, 109, 111, 116, 118, 118, 122, 122, 130, 130, 133, 134, 136, 137, 139, 144, 146, 151, 154, 164, 166, 170, 172, 173, 177, 177, 185, 186, 189, 194, 203, 212, 214, 215, 217, 218, 222, 227, 240, 243, 246, 246, 257, 265, 271, 275, 280, 286, 289, 297, 299, 302, 305, 320, 322, 325, 330, 356, 358, 374, 376, 388, 390, 390, 392, 392, 394, 395, 397, 415, 417, 417, 419, 419, 422, 422, 424, 447, 459, 460, 5950, 0, 675, 1, 0, 0, 0, 2, 681, 1, 0, 0, 0, 4, 701, 1, 0, 0, 0, 6, 703, 1, 0, 0, 0, 8, 735, 1, 0, 0, 0, 10, 864, 1, 0, 0, 0, 12, 878, 1, 0, 0, 0, 14, 895, 1, 0, 0, 0, 16, 913, 1, 0, 0, 0, 18, 936, 1, 0, 0, 0, 20, 945, 1, 0, 0, 0, 22, 961, 1, 0, 0, 0, 24, 963, 1, 0, 0, 0, 26, 973, 1, 0, 0, 0, 28, 1003, 1, 0, 0, 0, 30, 1030, 1, 0, 0, 0, 32, 1085, 1, 0, 0, 0, 34, 1098, 1, 0, 0, 0, 36, 1147, 1, 0, 0, 0, 38, 1166, 1, 0, 0, 0, 40, 1168, 1, 0, 0, 0, 42, 1176, 1, 0, 0, 0, 44, 1181, 1, 0, 0, 0, 46, 1215, 1, 0, 0, 0, 48, 1217, 1, 0, 0, 0, 50, 1222, 1, 0, 0, 0, 52, 1233, 1, 0, 0, 0, 54, 1238, 1, 0, 0, 0, 56, 1246, 1, 0, 0, 0, 58, 1254, 1, 0, 0, 0, 60, 1262, 1, 0, 0, 0, 62, 1270, 1, 0, 0, 0, 64, 1279, 1, 0, 0, 0, 66, 1299, 1, 0, 0, 0, 68, 1301, 1, 0, 0, 0, 70, 1318, 1, 0, 0, 0, 72, 1323, 1, 0, 0, 0, 74, 1329, 1, 0, 0, 0, 76, 1337, 1, 0, 0, 0, 78, 1373, 1, 0, 0, 0, 80, 1421, 1, 0, 0, 0, 82, 1427, 1, 0, 0, 0, 84, 1438, 1, 0, 0, 0, 86, 1440, 1, 0, 0, 0, 88, 1454, 1, 0, 0, 0, 90, 1456, 1, 0, 0, 0, 92, 1465, 1, 0, 0, 0, 94, 1485, 1, 0, 0, 0, 96, 1513, 1, 0, 0, 0, 98, 1551, 1, 0, 0, 0, 100, 1553, 1, 0, 0, 0, 102, 1580, 1, 0, 0, 0, 104, 1583, 1, 0, 0, 0, 106, 1589, 1, 0, 0, 0, 108, 1597, 1, 0, 0, 0, 110, 1604, 1, 0, 0, 0, 112, 1606, 1, 0, 0, 0, 114, 1616, 1, 0, 0, 0, 116, 1630, 1, 0, 0, 0, 118, 1632, 1, 0, 0, 0, 120, 1690, 1, 0, 0, 0, 122, 1704, 1, 0, 0, 0, 124, 1724, 1, 0, 0, 0, 126, 1739, 1, 0, 0, 0, 128, 1741, 1, 0, 0, 0, 130, 1747, 1, 0, 0, 0, 132, 1755, 1, 0, 0, 0, 134, 1757, 1, 0, 0, 0, 136, 1765, 1, 0, 0, 0, 138, 1774, 1, 0, 0, 0, 140, 1798, 1, 0, 0, 0, 142, 1801, 1, 0, 0, 0, 144, 1805, 1, 0, 0, 0, 146, 1808, 1, 0, 0, 0, 148, 1842, 1, 0, 0, 0, 150, 1857, 1, 0, 0, 0, 152, 1859, 1, 0, 0, 0, 154, 1867, 1, 0, 0, 0, 156, 1875, 1, 0, 0, 0, 158, 1897, 1, 0, 0, 0, 160, 1916, 1, 0, 0, 0, 162, 1924, 1, 0, 0, 0, 164, 1930, 1, 0, 0, 0, 166, 1933, 1, 0, 0, 0, 168, 1939, 1, 0, 0, 0, 170, 1949, 1, 0, 0, 0, 172, 1957, 1, 0, 0, 0, 174, 1959, 1, 0, 0, 0, 176, 1966, 1, 0, 0, 0, 178, 1974, 1, 0, 0, 0, 180, 1979, 1, 0, 0, 0, 182, 2302, 1, 0, 0, 0, 184, 2304, 1, 0, 0, 0, 186, 2311, 1, 0, 0, 0, 188, 2321, 1, 0, 0, 0, 190, 2335, 1, 0, 0, 0, 192, 2344, 1, 0, 0, 0, 194, 2354, 1, 0, 0, 0, 196, 2366, 1, 0, 0, 0, 198, 2371, 1, 0, 0, 0, 200, 2376, 1, 0, 0, 0, 202, 2416, 1, 0, 0, 0, 204, 2438, 1, 0, 0, 0, 206, 2440, 1, 0, 0, 0, 208, 2461, 1, 0, 0, 0, 210, 2473, 1, 0, 0, 0, 212, 2483, 1, 0, 0, 0, 214, 2485, 1, 0, 0, 0, 216, 2487, 1, 0, 0, 0, 218, 2491, 1, 0, 0, 0, 220, 2494, 1, 0, 0, 0, 222, 2506, 1, 0, 0, 0, 224, 2522, 1, 0, 0, 0, 226, 2524, 1, 0, 0, 0, 228, 2530, 1, 0, 0, 0, 230, 2532, 1, 0, 0, 0, 232, 2536, 1, 0, 0, 0, 234, 2551, 1, 0, 0, 0, 236, 2567, 1, 0, 0, 0, 238, 2601, 1, 0, 0, 0, 240, 2615, 1, 0, 0, 0, 242, 2625, 1, 0, 0, 0, 244, 2630, 1, 0, 0, 0, 246, 2648, 1, 0, 0, 0, 248, 2666, 1, 0, 0, 0, 250, 2668, 1, 0, 0, 0, 252, 2671, 1, 0, 0, 0, 254, 2675, 1, 0, 0, 0, 256, 2689, 1, 0, 0, 0, 258, 2692, 1, 0, 0, 0, 260, 2706, 1, 0, 0, 0, 262, 2734, 1, 0, 0, 0, 264, 2738, 1, 0, 0, 0, 266, 2740, 1, 0, 0, 0, 268, 2742, 1, 0, 0, 0, 270, 2747, 1, 0, 0, 0, 272, 2769, 1, 0, 0, 0, 274, 2771, 1, 0, 0, 0, 276, 2788, 1, 0, 0, 0, 278, 2790, 1, 0, 0, 0, 280, 2853, 1, 0, 0, 0, 282, 2855, 1, 0, 0, 0, 284, 2863, 1, 0, 0, 0, 286, 2867, 1, 0, 0, 0, 288, 2895, 1, 0, 0, 0, 290, 2897, 1, 0, 0, 0, 292, 2903, 1, 0, 0, 0, 294, 2908, 1, 0, 0, 0, 296, 2913, 1, 0, 0, 0, 298, 2921, 1, 0, 0, 0, 300, 2929, 1, 0, 0, 0, 302, 2931, 1, 0, 0, 0, 304, 2939, 1, 0, 0, 0, 306, 2943, 1, 0, 0, 0, 308, 2950, 1, 0, 0, 0, 310, 2963, 1, 0, 0, 0, 312, 2967, 1, 0, 0, 0, 314, 2970, 1, 0, 0, 0, 316, 2978, 1, 0, 0, 0, 318, 2982, 1, 0, 0, 0, 320, 2990, 1, 0, 0, 0, 322, 2994, 1, 0, 0, 0, 324, 3002, 1, 0, 0, 0, 326, 3010, 1, 0, 0, 0, 328, 3015, 1, 0, 0, 0, 330, 3019, 1, 0, 0, 0, 332, 3021, 1, 0, 0, 0, 334, 3029, 1, 0, 0, 0, 336, 3040, 1, 0, 0, 0, 338, 3042, 1, 0, 0, 0, 340, 3054, 1, 0, 0, 0, 342, 3056, 1, 0, 0, 0, 344, 3064, 1, 0, 0, 0, 346, 3076, 1, 0, 0, 0, 348, 3078, 1, 0, 0, 0, 350, 3086, 1, 0, 0, 0, 352, 3088, 1, 0, 0, 0, 354, 3102, 1, 0, 0, 0, 356, 3104, 1, 0, 0, 0, 358, 3142, 1, 0, 0, 0, 360, 3144, 1, 0, 0, 0, 362, 3170, 1, 0, 0, 0, 364, 3176, 1, 0, 0, 0, 366, 3179, 1, 0, 0, 0, 368, 3186, 1, 0, 0, 0, 370, 3194, 1, 0, 0, 0, 372, 3196, 1, 0, 0, 0, 374, 3282, 1, 0, 0, 0, 376, 3284, 1, 0, 0, 0, 378, 3286, 1, 0, 0, 0, 380, 3343, 1, 0, 0, 0, 382, 3383, 1, 0, 0, 0, 384, 3385, 1, 0, 0, 0, 386, 3402, 1, 0, 0, 0, 388, 3407, 1, 0, 0, 0, 390, 3430, 1, 0, 0, 0, 392, 3432, 1, 0, 0, 0, 394, 3443, 1, 0, 0, 0, 396, 3449, 1, 0, 0, 0, 398, 3451, 1, 0, 0, 0, 400, 3453, 1, 0, 0, 0, 402, 3455, 1, 0, 0, 0, 404, 3480, 1, 0, 0, 0, 406, 3495, 1, 0, 0, 0, 408, 3506, 1, 0, 0, 0, 410, 3508, 1, 0, 0, 0, 412, 3512, 1, 0, 0, 0, 414, 3527, 1, 0, 0, 0, 416, 3531, 1, 0, 0, 0, 418, 3534, 1, 0, 0, 0, 420, 3540, 1, 0, 0, 0, 422, 3585, 1, 0, 0, 0, 424, 3587, 1, 0, 0, 0, 426, 3625, 1, 0, 0, 0, 428, 3629, 1, 0, 0, 0, 430, 3639, 1, 0, 0, 0, 432, 3643, 1, 0, 0, 0, 434, 3646, 1, 0, 0, 0, 436, 3660, 1, 0, 0, 0, 438, 3673, 1, 0, 0, 0, 440, 3683, 1, 0, 0, 0, 442, 3685, 1, 0, 0, 0, 444, 3694, 1, 0, 0, 0, 446, 3697, 1, 0, 0, 0, 448, 3709, 1, 0, 0, 0, 450, 3711, 1, 0, 0, 0, 452, 3715, 1, 0, 0, 0, 454, 3722, 1, 0, 0, 0, 456, 3730, 1, 0, 0, 0, 458, 3746, 1, 0, 0, 0, 460, 3781, 1, 0, 0, 0, 462, 3783, 1, 0, 0, 0, 464, 3787, 1, 0, 0, 0, 466, 3791, 1, 0, 0, 0, 468, 3808, 1, 0, 0, 0, 470, 3810, 1, 0, 0, 0, 472, 3836, 1, 0, 0, 0, 474, 3851, 1, 0, 0, 0, 476, 3859, 1, 0, 0, 0, 478, 3870, 1, 0, 0, 0, 480, 3894, 1, 0, 0, 0, 482, 3905, 1, 0, 0, 0, 484, 3917, 1, 0, 0, 0, 486, 3921, 1, 0, 0, 0, 488, 3943, 1, 0, 0, 0, 490, 3966, 1, 0, 0, 0, 492, 3998, 1, 0, 0, 0, 494, 4000, 1, 0, 0, 0, 496, 4002, 1, 0, 0, 0, 498, 4010, 1, 0, 0, 0, 500, 4016, 1, 0, 0, 0, 502, 4339, 1, 0, 0, 0, 504, 4362, 1, 0, 0, 0, 506, 4364, 1, 0, 0, 0, 508, 4372, 1, 0, 0, 0, 510, 4374, 1, 0, 0, 0, 512, 4382, 1, 0, 0, 0, 514, 4498, 1, 0, 0, 0, 516, 4500, 1, 0, 0, 0, 518, 4546, 1, 0, 0, 0, 520, 4562, 1, 0, 0, 0, 522, 4564, 1, 0, 0, 0, 524, 4611, 1, 0, 0, 0, 526, 4613, 1, 0, 0, 0, 528, 4628, 1, 0, 0, 0, 530, 4640, 1, 0, 0, 0, 532, 4644, 1, 0, 0, 0, 534, 4646, 1, 0, 0, 0, 536, 4670, 1, 0, 0, 0, 538, 4692, 1, 0, 0, 0, 540, 4704, 1, 0, 0, 0, 542, 4720, 1, 0, 0, 0, 544, 4722, 1, 0, 0, 0, 546, 4725, 1, 0, 0, 0, 548, 4728, 1, 0, 0, 0, 550, 4731, 1, 0, 0, 0, 552, 4734, 1, 0, 0, 0, 554, 4742, 1, 0, 0, 0, 556, 4746, 1, 0, 0, 0, 558, 4766, 1, 0, 0, 0, 560, 4784, 1, 0, 0, 0, 562, 4786, 1, 0, 0, 0, 564, 4812, 1, 0, 0, 0, 566, 4814, 1, 0, 0, 0, 568, 4832, 1, 0, 0, 0, 570, 4834, 1, 0, 0, 0, 572, 4836, 1, 0, 0, 0, 574, 4838, 1, 0, 0, 0, 576, 4842, 1, 0, 0, 0, 578, 4857, 1, 0, 0, 0, 580, 4865, 1, 0, 0, 0, 582, 4867, 1, 0, 0, 0, 584, 4873, 1, 0, 0, 0, 586, 4875, 1, 0, 0, 0, 588, 4883, 1, 0, 0, 0, 590, 4885, 1, 0, 0, 0, 592, 4888, 1, 0, 0, 0, 594, 4950, 1, 0, 0, 0, 596, 4953, 1, 0, 0, 0, 598, 4957, 1, 0, 0, 0, 600, 4997, 1, 0, 0, 0, 602, 5011, 1, 0, 0, 0, 604, 5013, 1, 0, 0, 0, 606, 5015, 1, 0, 0, 0, 608, 5023, 1, 0, 0, 0, 610, 5025, 1, 0, 0, 0, 612, 5033, 1, 0, 0, 0, 614, 5042, 1, 0, 0, 0, 616, 5046, 1, 0, 0, 0, 618, 5077, 1, 0, 0, 0, 620, 5079, 1, 0, 0, 0, 622, 5087, 1, 0, 0, 0, 624, 5096, 1, 0, 0, 0, 626, 5120, 1, 0, 0, 0, 628, 5122, 1, 0, 0, 0, 630, 5138, 1, 0, 0, 0, 632, 5145, 1, 0, 0, 0, 634, 5147, 1, 0, 0, 0, 636, 5158, 1, 0, 0, 0, 638, 5165, 1, 0, 0, 0, 640, 5167, 1, 0, 0, 0, 642, 5187, 1, 0, 0, 0, 644, 5189, 1, 0, 0, 0, 646, 5197, 1, 0, 0, 0, 648, 5208, 1, 0, 0, 0, 650, 5215, 1, 0, 0, 0, 652, 5217, 1, 0, 0, 0, 654, 5230, 1, 0, 0, 0, 656, 5232, 1, 0, 0, 0, 658, 5234, 1, 0, 0, 0, 660, 5243, 1, 0, 0, 0, 662, 5245, 1, 0, 0, 0, 664, 5257, 1, 0, 0, 0, 666, 5262, 1, 0, 0, 0, 668, 5264, 1, 0, 0, 0, 670, 5266, 1, 0, 0, 0, 672, 674, 3, 2, 1, 0, 673, 672, 1, 0, 0, 0, 674, 677, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 678, 1, 0, 0, 0, 677, 675, 1, 0, 0, 0, 678, 679, 5, 0, 0, 1, 679, 1, 1, 0, 0, 0, 680, 682, 3, 656, 328, 0, 681, 680, 1, 0, 0, 0, 681, 682, 1, 0, 0, 0, 682, 686, 1, 0, 0, 0, 683, 687, 3, 4, 2, 0, 684, 687, 3, 500, 250, 0, 685, 687, 3, 560, 280, 0, 686, 683, 1, 0, 0, 0, 686, 684, 1, 0, 0, 0, 686, 685, 1, 0, 0, 0, 687, 689, 1, 0, 0, 0, 688, 690, 5, 461, 0, 0, 689, 688, 1, 0, 0, 0, 689, 690, 1, 0, 0, 0, 690, 692, 1, 0, 0, 0, 691, 693, 5, 457, 0, 0, 692, 691, 1, 0, 0, 0, 692, 693, 1, 0, 0, 0, 693, 3, 1, 0, 0, 0, 694, 702, 3, 8, 4, 0, 695, 702, 3, 10, 5, 0, 696, 702, 3, 32, 16, 0, 697, 702, 3, 34, 17, 0, 698, 702, 3, 36, 18, 0, 699, 702, 3, 6, 3, 0, 700, 702, 3, 38, 19, 0, 701, 694, 1, 0, 0, 0, 701, 695, 1, 0, 0, 0, 701, 696, 1, 0, 0, 0, 701, 697, 1, 0, 0, 0, 701, 698, 1, 0, 0, 0, 701, 699, 1, 0, 0, 0, 701, 700, 1, 0, 0, 0, 702, 5, 1, 0, 0, 0, 703, 704, 5, 382, 0, 0, 704, 705, 5, 185, 0, 0, 705, 706, 5, 47, 0, 0, 706, 711, 3, 510, 255, 0, 707, 708, 5, 462, 0, 0, 708, 710, 3, 510, 255, 0, 709, 707, 1, 0, 0, 0, 710, 713, 1, 0, 0, 0, 711, 709, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 714, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 714, 715, 5, 71, 0, 0, 715, 720, 3, 508, 254, 0, 716, 717, 5, 280, 0, 0, 717, 719, 3, 508, 254, 0, 718, 716, 1, 0, 0, 0, 719, 722, 1, 0, 0, 0, 720, 718, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 728, 1, 0, 0, 0, 722, 720, 1, 0, 0, 0, 723, 726, 5, 284, 0, 0, 724, 727, 3, 646, 323, 0, 725, 727, 5, 482, 0, 0, 726, 724, 1, 0, 0, 0, 726, 725, 1, 0, 0, 0, 727, 729, 1, 0, 0, 0, 728, 723, 1, 0, 0, 0, 728, 729, 1, 0, 0, 0, 729, 732, 1, 0, 0, 0, 730, 731, 5, 420, 0, 0, 731, 733, 5, 421, 0, 0, 732, 730, 1, 0, 0, 0, 732, 733, 1, 0, 0, 0, 733, 7, 1, 0, 0, 0, 734, 736, 3, 656, 328, 0, 735, 734, 1, 0, 0, 0, 735, 736, 1, 0, 0, 0, 736, 740, 1, 0, 0, 0, 737, 739, 3, 658, 329, 0, 738, 737, 1, 0, 0, 0, 739, 742, 1, 0, 0, 0, 740, 738, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, 743, 1, 0, 0, 0, 742, 740, 1, 0, 0, 0, 743, 746, 5, 17, 0, 0, 744, 745, 5, 281, 0, 0, 745, 747, 7, 0, 0, 0, 746, 744, 1, 0, 0, 0, 746, 747, 1, 0, 0, 0, 747, 767, 1, 0, 0, 0, 748, 768, 3, 80, 40, 0, 749, 768, 3, 112, 56, 0, 750, 768, 3, 128, 64, 0, 751, 768, 3, 156, 78, 0, 752, 768, 3, 158, 79, 0, 753, 768, 3, 306, 153, 0, 754, 768, 3, 308, 154, 0, 755, 768, 3, 134, 67, 0, 756, 768, 3, 146, 73, 0, 757, 768, 3, 412, 206, 0, 758, 768, 3, 420, 210, 0, 759, 768, 3, 428, 214, 0, 760, 768, 3, 434, 217, 0, 761, 768, 3, 454, 227, 0, 762, 768, 3, 456, 228, 0, 763, 768, 3, 458, 229, 0, 764, 768, 3, 478, 239, 0, 765, 768, 3, 480, 240, 0, 766, 768, 3, 486, 243, 0, 767, 748, 1, 0, 0, 0, 767, 749, 1, 0, 0, 0, 767, 750, 1, 0, 0, 0, 767, 751, 1, 0, 0, 0, 767, 752, 1, 0, 0, 0, 767, 753, 1, 0, 0, 0, 767, 754, 1, 0, 0, 0, 767, 755, 1, 0, 0, 0, 767, 756, 1, 0, 0, 0, 767, 757, 1, 0, 0, 0, 767, 758, 1, 0, 0, 0, 767, 759, 1, 0, 0, 0, 767, 760, 1, 0, 0, 0, 767, 761, 1, 0, 0, 0, 767, 762, 1, 0, 0, 0, 767, 763, 1, 0, 0, 0, 767, 764, 1, 0, 0, 0, 767, 765, 1, 0, 0, 0, 767, 766, 1, 0, 0, 0, 768, 9, 1, 0, 0, 0, 769, 770, 5, 18, 0, 0, 770, 771, 5, 23, 0, 0, 771, 773, 3, 646, 323, 0, 772, 774, 3, 120, 60, 0, 773, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 773, 1, 0, 0, 0, 775, 776, 1, 0, 0, 0, 776, 865, 1, 0, 0, 0, 777, 778, 5, 18, 0, 0, 778, 779, 5, 27, 0, 0, 779, 781, 3, 646, 323, 0, 780, 782, 3, 122, 61, 0, 781, 780, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 781, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 865, 1, 0, 0, 0, 785, 786, 5, 18, 0, 0, 786, 787, 5, 28, 0, 0, 787, 789, 3, 646, 323, 0, 788, 790, 3, 124, 62, 0, 789, 788, 1, 0, 0, 0, 790, 791, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 865, 1, 0, 0, 0, 793, 794, 5, 18, 0, 0, 794, 795, 5, 36, 0, 0, 795, 797, 3, 646, 323, 0, 796, 798, 3, 126, 63, 0, 797, 796, 1, 0, 0, 0, 798, 799, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 865, 1, 0, 0, 0, 801, 802, 5, 18, 0, 0, 802, 803, 5, 308, 0, 0, 803, 804, 5, 331, 0, 0, 804, 805, 3, 646, 323, 0, 805, 806, 5, 47, 0, 0, 806, 811, 3, 464, 232, 0, 807, 808, 5, 462, 0, 0, 808, 810, 3, 464, 232, 0, 809, 807, 1, 0, 0, 0, 810, 813, 1, 0, 0, 0, 811, 809, 1, 0, 0, 0, 811, 812, 1, 0, 0, 0, 812, 865, 1, 0, 0, 0, 813, 811, 1, 0, 0, 0, 814, 815, 5, 18, 0, 0, 815, 816, 5, 308, 0, 0, 816, 817, 5, 306, 0, 0, 817, 818, 3, 646, 323, 0, 818, 819, 5, 47, 0, 0, 819, 824, 3, 464, 232, 0, 820, 821, 5, 462, 0, 0, 821, 823, 3, 464, 232, 0, 822, 820, 1, 0, 0, 0, 823, 826, 1, 0, 0, 0, 824, 822, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 865, 1, 0, 0, 0, 826, 824, 1, 0, 0, 0, 827, 828, 5, 18, 0, 0, 828, 829, 5, 209, 0, 0, 829, 830, 5, 92, 0, 0, 830, 831, 7, 1, 0, 0, 831, 832, 3, 646, 323, 0, 832, 833, 5, 184, 0, 0, 833, 835, 5, 482, 0, 0, 834, 836, 3, 12, 6, 0, 835, 834, 1, 0, 0, 0, 836, 837, 1, 0, 0, 0, 837, 835, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 865, 1, 0, 0, 0, 839, 840, 5, 18, 0, 0, 840, 841, 5, 427, 0, 0, 841, 865, 3, 492, 246, 0, 842, 843, 5, 18, 0, 0, 843, 844, 5, 33, 0, 0, 844, 845, 3, 646, 323, 0, 845, 847, 5, 466, 0, 0, 846, 848, 3, 16, 8, 0, 847, 846, 1, 0, 0, 0, 848, 849, 1, 0, 0, 0, 849, 847, 1, 0, 0, 0, 849, 850, 1, 0, 0, 0, 850, 851, 1, 0, 0, 0, 851, 852, 5, 467, 0, 0, 852, 865, 1, 0, 0, 0, 853, 854, 5, 18, 0, 0, 854, 855, 5, 34, 0, 0, 855, 856, 3, 646, 323, 0, 856, 858, 5, 466, 0, 0, 857, 859, 3, 16, 8, 0, 858, 857, 1, 0, 0, 0, 859, 860, 1, 0, 0, 0, 860, 858, 1, 0, 0, 0, 860, 861, 1, 0, 0, 0, 861, 862, 1, 0, 0, 0, 862, 863, 5, 467, 0, 0, 863, 865, 1, 0, 0, 0, 864, 769, 1, 0, 0, 0, 864, 777, 1, 0, 0, 0, 864, 785, 1, 0, 0, 0, 864, 793, 1, 0, 0, 0, 864, 801, 1, 0, 0, 0, 864, 814, 1, 0, 0, 0, 864, 827, 1, 0, 0, 0, 864, 839, 1, 0, 0, 0, 864, 842, 1, 0, 0, 0, 864, 853, 1, 0, 0, 0, 865, 11, 1, 0, 0, 0, 866, 867, 5, 47, 0, 0, 867, 872, 3, 14, 7, 0, 868, 869, 5, 462, 0, 0, 869, 871, 3, 14, 7, 0, 870, 868, 1, 0, 0, 0, 871, 874, 1, 0, 0, 0, 872, 870, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 879, 1, 0, 0, 0, 874, 872, 1, 0, 0, 0, 875, 876, 5, 210, 0, 0, 876, 877, 5, 206, 0, 0, 877, 879, 5, 207, 0, 0, 878, 866, 1, 0, 0, 0, 878, 875, 1, 0, 0, 0, 879, 13, 1, 0, 0, 0, 880, 881, 5, 203, 0, 0, 881, 882, 5, 451, 0, 0, 882, 896, 5, 478, 0, 0, 883, 884, 5, 204, 0, 0, 884, 885, 5, 451, 0, 0, 885, 896, 5, 478, 0, 0, 886, 887, 5, 478, 0, 0, 887, 888, 5, 451, 0, 0, 888, 896, 5, 478, 0, 0, 889, 890, 5, 478, 0, 0, 890, 891, 5, 451, 0, 0, 891, 896, 5, 92, 0, 0, 892, 893, 5, 478, 0, 0, 893, 894, 5, 451, 0, 0, 894, 896, 5, 446, 0, 0, 895, 880, 1, 0, 0, 0, 895, 883, 1, 0, 0, 0, 895, 886, 1, 0, 0, 0, 895, 889, 1, 0, 0, 0, 895, 892, 1, 0, 0, 0, 896, 15, 1, 0, 0, 0, 897, 899, 3, 18, 9, 0, 898, 900, 5, 461, 0, 0, 899, 898, 1, 0, 0, 0, 899, 900, 1, 0, 0, 0, 900, 914, 1, 0, 0, 0, 901, 903, 3, 22, 11, 0, 902, 904, 5, 461, 0, 0, 903, 902, 1, 0, 0, 0, 903, 904, 1, 0, 0, 0, 904, 914, 1, 0, 0, 0, 905, 907, 3, 24, 12, 0, 906, 908, 5, 461, 0, 0, 907, 906, 1, 0, 0, 0, 907, 908, 1, 0, 0, 0, 908, 914, 1, 0, 0, 0, 909, 911, 3, 26, 13, 0, 910, 912, 5, 461, 0, 0, 911, 910, 1, 0, 0, 0, 911, 912, 1, 0, 0, 0, 912, 914, 1, 0, 0, 0, 913, 897, 1, 0, 0, 0, 913, 901, 1, 0, 0, 0, 913, 905, 1, 0, 0, 0, 913, 909, 1, 0, 0, 0, 914, 17, 1, 0, 0, 0, 915, 916, 5, 47, 0, 0, 916, 917, 3, 20, 10, 0, 917, 918, 5, 92, 0, 0, 918, 919, 3, 648, 324, 0, 919, 937, 1, 0, 0, 0, 920, 921, 5, 47, 0, 0, 921, 922, 5, 464, 0, 0, 922, 927, 3, 20, 10, 0, 923, 924, 5, 462, 0, 0, 924, 926, 3, 20, 10, 0, 925, 923, 1, 0, 0, 0, 926, 929, 1, 0, 0, 0, 927, 925, 1, 0, 0, 0, 927, 928, 1, 0, 0, 0, 928, 930, 1, 0, 0, 0, 929, 927, 1, 0, 0, 0, 930, 931, 5, 465, 0, 0, 931, 932, 5, 92, 0, 0, 932, 933, 3, 648, 324, 0, 933, 937, 1, 0, 0, 0, 934, 935, 5, 47, 0, 0, 935, 937, 3, 20, 10, 0, 936, 915, 1, 0, 0, 0, 936, 920, 1, 0, 0, 0, 936, 934, 1, 0, 0, 0, 937, 19, 1, 0, 0, 0, 938, 939, 3, 648, 324, 0, 939, 940, 5, 451, 0, 0, 940, 941, 3, 404, 202, 0, 941, 946, 1, 0, 0, 0, 942, 943, 5, 478, 0, 0, 943, 944, 5, 451, 0, 0, 944, 946, 3, 404, 202, 0, 945, 938, 1, 0, 0, 0, 945, 942, 1, 0, 0, 0, 946, 21, 1, 0, 0, 0, 947, 948, 5, 379, 0, 0, 948, 949, 5, 381, 0, 0, 949, 950, 3, 648, 324, 0, 950, 951, 5, 466, 0, 0, 951, 952, 3, 364, 182, 0, 952, 953, 5, 467, 0, 0, 953, 962, 1, 0, 0, 0, 954, 955, 5, 379, 0, 0, 955, 956, 5, 380, 0, 0, 956, 957, 3, 648, 324, 0, 957, 958, 5, 466, 0, 0, 958, 959, 3, 364, 182, 0, 959, 960, 5, 467, 0, 0, 960, 962, 1, 0, 0, 0, 961, 947, 1, 0, 0, 0, 961, 954, 1, 0, 0, 0, 962, 23, 1, 0, 0, 0, 963, 964, 5, 19, 0, 0, 964, 965, 5, 184, 0, 0, 965, 970, 3, 648, 324, 0, 966, 967, 5, 462, 0, 0, 967, 969, 3, 648, 324, 0, 968, 966, 1, 0, 0, 0, 969, 972, 1, 0, 0, 0, 970, 968, 1, 0, 0, 0, 970, 971, 1, 0, 0, 0, 971, 25, 1, 0, 0, 0, 972, 970, 1, 0, 0, 0, 973, 974, 5, 414, 0, 0, 974, 975, 3, 648, 324, 0, 975, 976, 5, 137, 0, 0, 976, 977, 5, 466, 0, 0, 977, 978, 3, 364, 182, 0, 978, 979, 5, 467, 0, 0, 979, 27, 1, 0, 0, 0, 980, 981, 5, 364, 0, 0, 981, 982, 7, 2, 0, 0, 982, 985, 3, 646, 323, 0, 983, 984, 5, 413, 0, 0, 984, 986, 3, 646, 323, 0, 985, 983, 1, 0, 0, 0, 985, 986, 1, 0, 0, 0, 986, 1004, 1, 0, 0, 0, 987, 988, 5, 365, 0, 0, 988, 989, 5, 33, 0, 0, 989, 1004, 3, 646, 323, 0, 990, 991, 5, 282, 0, 0, 991, 992, 5, 366, 0, 0, 992, 993, 5, 33, 0, 0, 993, 1004, 3, 646, 323, 0, 994, 995, 5, 362, 0, 0, 995, 999, 5, 464, 0, 0, 996, 998, 3, 30, 15, 0, 997, 996, 1, 0, 0, 0, 998, 1001, 1, 0, 0, 0, 999, 997, 1, 0, 0, 0, 999, 1000, 1, 0, 0, 0, 1000, 1002, 1, 0, 0, 0, 1001, 999, 1, 0, 0, 0, 1002, 1004, 5, 465, 0, 0, 1003, 980, 1, 0, 0, 0, 1003, 987, 1, 0, 0, 0, 1003, 990, 1, 0, 0, 0, 1003, 994, 1, 0, 0, 0, 1004, 29, 1, 0, 0, 0, 1005, 1006, 5, 362, 0, 0, 1006, 1007, 5, 154, 0, 0, 1007, 1012, 5, 478, 0, 0, 1008, 1009, 5, 33, 0, 0, 1009, 1013, 3, 646, 323, 0, 1010, 1011, 5, 30, 0, 0, 1011, 1013, 3, 646, 323, 0, 1012, 1008, 1, 0, 0, 0, 1012, 1010, 1, 0, 0, 0, 1012, 1013, 1, 0, 0, 0, 1013, 1015, 1, 0, 0, 0, 1014, 1016, 5, 461, 0, 0, 1015, 1014, 1, 0, 0, 0, 1015, 1016, 1, 0, 0, 0, 1016, 1031, 1, 0, 0, 0, 1017, 1018, 5, 362, 0, 0, 1018, 1019, 5, 478, 0, 0, 1019, 1023, 5, 464, 0, 0, 1020, 1022, 3, 30, 15, 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, 5, 465, 0, 0, 1027, 1029, 5, 461, 0, 0, 1028, 1027, 1, 0, 0, 0, 1028, 1029, 1, 0, 0, 0, 1029, 1031, 1, 0, 0, 0, 1030, 1005, 1, 0, 0, 0, 1030, 1017, 1, 0, 0, 0, 1031, 31, 1, 0, 0, 0, 1032, 1033, 5, 19, 0, 0, 1033, 1034, 5, 23, 0, 0, 1034, 1086, 3, 646, 323, 0, 1035, 1036, 5, 19, 0, 0, 1036, 1037, 5, 27, 0, 0, 1037, 1086, 3, 646, 323, 0, 1038, 1039, 5, 19, 0, 0, 1039, 1040, 5, 28, 0, 0, 1040, 1086, 3, 646, 323, 0, 1041, 1042, 5, 19, 0, 0, 1042, 1043, 5, 37, 0, 0, 1043, 1086, 3, 646, 323, 0, 1044, 1045, 5, 19, 0, 0, 1045, 1046, 5, 30, 0, 0, 1046, 1086, 3, 646, 323, 0, 1047, 1048, 5, 19, 0, 0, 1048, 1049, 5, 31, 0, 0, 1049, 1086, 3, 646, 323, 0, 1050, 1051, 5, 19, 0, 0, 1051, 1052, 5, 33, 0, 0, 1052, 1086, 3, 646, 323, 0, 1053, 1054, 5, 19, 0, 0, 1054, 1055, 5, 34, 0, 0, 1055, 1086, 3, 646, 323, 0, 1056, 1057, 5, 19, 0, 0, 1057, 1058, 5, 29, 0, 0, 1058, 1086, 3, 646, 323, 0, 1059, 1060, 5, 19, 0, 0, 1060, 1061, 5, 36, 0, 0, 1061, 1086, 3, 646, 323, 0, 1062, 1063, 5, 19, 0, 0, 1063, 1064, 5, 113, 0, 0, 1064, 1065, 5, 114, 0, 0, 1065, 1086, 3, 646, 323, 0, 1066, 1067, 5, 19, 0, 0, 1067, 1068, 5, 41, 0, 0, 1068, 1069, 3, 646, 323, 0, 1069, 1070, 5, 92, 0, 0, 1070, 1071, 3, 646, 323, 0, 1071, 1086, 1, 0, 0, 0, 1072, 1073, 5, 19, 0, 0, 1073, 1074, 5, 308, 0, 0, 1074, 1075, 5, 331, 0, 0, 1075, 1086, 3, 646, 323, 0, 1076, 1077, 5, 19, 0, 0, 1077, 1078, 5, 308, 0, 0, 1078, 1079, 5, 306, 0, 0, 1079, 1086, 3, 646, 323, 0, 1080, 1081, 5, 19, 0, 0, 1081, 1082, 5, 424, 0, 0, 1082, 1083, 5, 425, 0, 0, 1083, 1084, 5, 306, 0, 0, 1084, 1086, 3, 646, 323, 0, 1085, 1032, 1, 0, 0, 0, 1085, 1035, 1, 0, 0, 0, 1085, 1038, 1, 0, 0, 0, 1085, 1041, 1, 0, 0, 0, 1085, 1044, 1, 0, 0, 0, 1085, 1047, 1, 0, 0, 0, 1085, 1050, 1, 0, 0, 0, 1085, 1053, 1, 0, 0, 0, 1085, 1056, 1, 0, 0, 0, 1085, 1059, 1, 0, 0, 0, 1085, 1062, 1, 0, 0, 0, 1085, 1066, 1, 0, 0, 0, 1085, 1072, 1, 0, 0, 0, 1085, 1076, 1, 0, 0, 0, 1085, 1080, 1, 0, 0, 0, 1086, 33, 1, 0, 0, 0, 1087, 1088, 5, 20, 0, 0, 1088, 1089, 5, 23, 0, 0, 1089, 1090, 3, 646, 323, 0, 1090, 1091, 5, 410, 0, 0, 1091, 1092, 5, 482, 0, 0, 1092, 1099, 1, 0, 0, 0, 1093, 1094, 5, 20, 0, 0, 1094, 1095, 5, 29, 0, 0, 1095, 1096, 5, 482, 0, 0, 1096, 1097, 5, 410, 0, 0, 1097, 1099, 5, 482, 0, 0, 1098, 1087, 1, 0, 0, 0, 1098, 1093, 1, 0, 0, 0, 1099, 35, 1, 0, 0, 0, 1100, 1109, 5, 21, 0, 0, 1101, 1110, 5, 33, 0, 0, 1102, 1110, 5, 30, 0, 0, 1103, 1110, 5, 34, 0, 0, 1104, 1110, 5, 31, 0, 0, 1105, 1110, 5, 28, 0, 0, 1106, 1110, 5, 37, 0, 0, 1107, 1108, 5, 343, 0, 0, 1108, 1110, 5, 342, 0, 0, 1109, 1101, 1, 0, 0, 0, 1109, 1102, 1, 0, 0, 0, 1109, 1103, 1, 0, 0, 0, 1109, 1104, 1, 0, 0, 0, 1109, 1105, 1, 0, 0, 0, 1109, 1106, 1, 0, 0, 0, 1109, 1107, 1, 0, 0, 0, 1110, 1111, 1, 0, 0, 0, 1111, 1112, 3, 646, 323, 0, 1112, 1113, 5, 410, 0, 0, 1113, 1114, 5, 215, 0, 0, 1114, 1120, 5, 478, 0, 0, 1115, 1118, 5, 284, 0, 0, 1116, 1119, 3, 646, 323, 0, 1117, 1119, 5, 482, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1117, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1115, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1148, 1, 0, 0, 0, 1122, 1131, 5, 21, 0, 0, 1123, 1132, 5, 33, 0, 0, 1124, 1132, 5, 30, 0, 0, 1125, 1132, 5, 34, 0, 0, 1126, 1132, 5, 31, 0, 0, 1127, 1132, 5, 28, 0, 0, 1128, 1132, 5, 37, 0, 0, 1129, 1130, 5, 343, 0, 0, 1130, 1132, 5, 342, 0, 0, 1131, 1123, 1, 0, 0, 0, 1131, 1124, 1, 0, 0, 0, 1131, 1125, 1, 0, 0, 0, 1131, 1126, 1, 0, 0, 0, 1131, 1127, 1, 0, 0, 0, 1131, 1128, 1, 0, 0, 0, 1131, 1129, 1, 0, 0, 0, 1132, 1133, 1, 0, 0, 0, 1133, 1134, 3, 646, 323, 0, 1134, 1137, 5, 410, 0, 0, 1135, 1138, 3, 646, 323, 0, 1136, 1138, 5, 482, 0, 0, 1137, 1135, 1, 0, 0, 0, 1137, 1136, 1, 0, 0, 0, 1138, 1148, 1, 0, 0, 0, 1139, 1140, 5, 21, 0, 0, 1140, 1141, 5, 23, 0, 0, 1141, 1142, 3, 646, 323, 0, 1142, 1145, 5, 410, 0, 0, 1143, 1146, 3, 646, 323, 0, 1144, 1146, 5, 482, 0, 0, 1145, 1143, 1, 0, 0, 0, 1145, 1144, 1, 0, 0, 0, 1146, 1148, 1, 0, 0, 0, 1147, 1100, 1, 0, 0, 0, 1147, 1122, 1, 0, 0, 0, 1147, 1139, 1, 0, 0, 0, 1148, 37, 1, 0, 0, 0, 1149, 1167, 3, 40, 20, 0, 1150, 1167, 3, 42, 21, 0, 1151, 1167, 3, 44, 22, 0, 1152, 1167, 3, 46, 23, 0, 1153, 1167, 3, 48, 24, 0, 1154, 1167, 3, 50, 25, 0, 1155, 1167, 3, 52, 26, 0, 1156, 1167, 3, 54, 27, 0, 1157, 1167, 3, 56, 28, 0, 1158, 1167, 3, 58, 29, 0, 1159, 1167, 3, 60, 30, 0, 1160, 1167, 3, 62, 31, 0, 1161, 1167, 3, 64, 32, 0, 1162, 1167, 3, 66, 33, 0, 1163, 1167, 3, 68, 34, 0, 1164, 1167, 3, 70, 35, 0, 1165, 1167, 3, 72, 36, 0, 1166, 1149, 1, 0, 0, 0, 1166, 1150, 1, 0, 0, 0, 1166, 1151, 1, 0, 0, 0, 1166, 1152, 1, 0, 0, 0, 1166, 1153, 1, 0, 0, 0, 1166, 1154, 1, 0, 0, 0, 1166, 1155, 1, 0, 0, 0, 1166, 1156, 1, 0, 0, 0, 1166, 1157, 1, 0, 0, 0, 1166, 1158, 1, 0, 0, 0, 1166, 1159, 1, 0, 0, 0, 1166, 1160, 1, 0, 0, 0, 1166, 1161, 1, 0, 0, 0, 1166, 1162, 1, 0, 0, 0, 1166, 1163, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1166, 1165, 1, 0, 0, 0, 1167, 39, 1, 0, 0, 0, 1168, 1169, 5, 17, 0, 0, 1169, 1170, 5, 29, 0, 0, 1170, 1171, 5, 430, 0, 0, 1171, 1174, 3, 646, 323, 0, 1172, 1173, 5, 445, 0, 0, 1173, 1175, 5, 478, 0, 0, 1174, 1172, 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1175, 41, 1, 0, 0, 0, 1176, 1177, 5, 19, 0, 0, 1177, 1178, 5, 29, 0, 0, 1178, 1179, 5, 430, 0, 0, 1179, 1180, 3, 646, 323, 0, 1180, 43, 1, 0, 0, 0, 1181, 1182, 5, 17, 0, 0, 1182, 1183, 5, 442, 0, 0, 1183, 1184, 5, 430, 0, 0, 1184, 1185, 3, 648, 324, 0, 1185, 1186, 5, 464, 0, 0, 1186, 1187, 3, 74, 37, 0, 1187, 1191, 5, 465, 0, 0, 1188, 1189, 5, 436, 0, 0, 1189, 1190, 5, 84, 0, 0, 1190, 1192, 5, 431, 0, 0, 1191, 1188, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 45, 1, 0, 0, 0, 1193, 1194, 5, 18, 0, 0, 1194, 1195, 5, 442, 0, 0, 1195, 1196, 5, 430, 0, 0, 1196, 1197, 3, 648, 324, 0, 1197, 1198, 5, 46, 0, 0, 1198, 1199, 5, 29, 0, 0, 1199, 1200, 5, 431, 0, 0, 1200, 1201, 5, 464, 0, 0, 1201, 1202, 3, 74, 37, 0, 1202, 1203, 5, 465, 0, 0, 1203, 1216, 1, 0, 0, 0, 1204, 1205, 5, 18, 0, 0, 1205, 1206, 5, 442, 0, 0, 1206, 1207, 5, 430, 0, 0, 1207, 1208, 3, 648, 324, 0, 1208, 1209, 5, 131, 0, 0, 1209, 1210, 5, 29, 0, 0, 1210, 1211, 5, 431, 0, 0, 1211, 1212, 5, 464, 0, 0, 1212, 1213, 3, 74, 37, 0, 1213, 1214, 5, 465, 0, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1193, 1, 0, 0, 0, 1215, 1204, 1, 0, 0, 0, 1216, 47, 1, 0, 0, 0, 1217, 1218, 5, 19, 0, 0, 1218, 1219, 5, 442, 0, 0, 1219, 1220, 5, 430, 0, 0, 1220, 1221, 3, 648, 324, 0, 1221, 49, 1, 0, 0, 0, 1222, 1223, 5, 432, 0, 0, 1223, 1224, 3, 74, 37, 0, 1224, 1225, 5, 92, 0, 0, 1225, 1226, 3, 646, 323, 0, 1226, 1227, 5, 464, 0, 0, 1227, 1228, 3, 76, 38, 0, 1228, 1231, 5, 465, 0, 0, 1229, 1230, 5, 71, 0, 0, 1230, 1232, 5, 478, 0, 0, 1231, 1229, 1, 0, 0, 0, 1231, 1232, 1, 0, 0, 0, 1232, 51, 1, 0, 0, 0, 1233, 1234, 5, 433, 0, 0, 1234, 1235, 3, 74, 37, 0, 1235, 1236, 5, 92, 0, 0, 1236, 1237, 3, 646, 323, 0, 1237, 53, 1, 0, 0, 0, 1238, 1239, 5, 432, 0, 0, 1239, 1240, 5, 386, 0, 0, 1240, 1241, 5, 92, 0, 0, 1241, 1242, 5, 30, 0, 0, 1242, 1243, 3, 646, 323, 0, 1243, 1244, 5, 410, 0, 0, 1244, 1245, 3, 74, 37, 0, 1245, 55, 1, 0, 0, 0, 1246, 1247, 5, 433, 0, 0, 1247, 1248, 5, 386, 0, 0, 1248, 1249, 5, 92, 0, 0, 1249, 1250, 5, 30, 0, 0, 1250, 1251, 3, 646, 323, 0, 1251, 1252, 5, 70, 0, 0, 1252, 1253, 3, 74, 37, 0, 1253, 57, 1, 0, 0, 0, 1254, 1255, 5, 432, 0, 0, 1255, 1256, 5, 25, 0, 0, 1256, 1257, 5, 92, 0, 0, 1257, 1258, 5, 33, 0, 0, 1258, 1259, 3, 646, 323, 0, 1259, 1260, 5, 410, 0, 0, 1260, 1261, 3, 74, 37, 0, 1261, 59, 1, 0, 0, 0, 1262, 1263, 5, 433, 0, 0, 1263, 1264, 5, 25, 0, 0, 1264, 1265, 5, 92, 0, 0, 1265, 1266, 5, 33, 0, 0, 1266, 1267, 3, 646, 323, 0, 1267, 1268, 5, 70, 0, 0, 1268, 1269, 3, 74, 37, 0, 1269, 61, 1, 0, 0, 0, 1270, 1271, 5, 432, 0, 0, 1271, 1272, 5, 440, 0, 0, 1272, 1273, 5, 92, 0, 0, 1273, 1274, 5, 308, 0, 0, 1274, 1275, 5, 306, 0, 0, 1275, 1276, 3, 646, 323, 0, 1276, 1277, 5, 410, 0, 0, 1277, 1278, 3, 74, 37, 0, 1278, 63, 1, 0, 0, 0, 1279, 1280, 5, 433, 0, 0, 1280, 1281, 5, 440, 0, 0, 1281, 1282, 5, 92, 0, 0, 1282, 1283, 5, 308, 0, 0, 1283, 1284, 5, 306, 0, 0, 1284, 1285, 3, 646, 323, 0, 1285, 1286, 5, 70, 0, 0, 1286, 1287, 3, 74, 37, 0, 1287, 65, 1, 0, 0, 0, 1288, 1289, 5, 18, 0, 0, 1289, 1290, 5, 58, 0, 0, 1290, 1291, 5, 429, 0, 0, 1291, 1292, 5, 441, 0, 0, 1292, 1300, 7, 3, 0, 0, 1293, 1294, 5, 18, 0, 0, 1294, 1295, 5, 58, 0, 0, 1295, 1296, 5, 429, 0, 0, 1296, 1297, 5, 437, 0, 0, 1297, 1298, 5, 447, 0, 0, 1298, 1300, 7, 4, 0, 0, 1299, 1288, 1, 0, 0, 0, 1299, 1293, 1, 0, 0, 0, 1300, 67, 1, 0, 0, 0, 1301, 1302, 5, 17, 0, 0, 1302, 1303, 5, 437, 0, 0, 1303, 1304, 5, 442, 0, 0, 1304, 1305, 5, 478, 0, 0, 1305, 1306, 5, 341, 0, 0, 1306, 1307, 5, 478, 0, 0, 1307, 1308, 5, 464, 0, 0, 1308, 1313, 3, 648, 324, 0, 1309, 1310, 5, 462, 0, 0, 1310, 1312, 3, 648, 324, 0, 1311, 1309, 1, 0, 0, 0, 1312, 1315, 1, 0, 0, 0, 1313, 1311, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, 1316, 1, 0, 0, 0, 1315, 1313, 1, 0, 0, 0, 1316, 1317, 5, 465, 0, 0, 1317, 69, 1, 0, 0, 0, 1318, 1319, 5, 19, 0, 0, 1319, 1320, 5, 437, 0, 0, 1320, 1321, 5, 442, 0, 0, 1321, 1322, 5, 478, 0, 0, 1322, 71, 1, 0, 0, 0, 1323, 1324, 5, 382, 0, 0, 1324, 1327, 5, 429, 0, 0, 1325, 1326, 5, 284, 0, 0, 1326, 1328, 3, 646, 323, 0, 1327, 1325, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, 73, 1, 0, 0, 0, 1329, 1334, 3, 646, 323, 0, 1330, 1331, 5, 462, 0, 0, 1331, 1333, 3, 646, 323, 0, 1332, 1330, 1, 0, 0, 0, 1333, 1336, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 75, 1, 0, 0, 0, 1336, 1334, 1, 0, 0, 0, 1337, 1342, 3, 78, 39, 0, 1338, 1339, 5, 462, 0, 0, 1339, 1341, 3, 78, 39, 0, 1340, 1338, 1, 0, 0, 0, 1341, 1344, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 77, 1, 0, 0, 0, 1344, 1342, 1, 0, 0, 0, 1345, 1374, 5, 17, 0, 0, 1346, 1374, 5, 99, 0, 0, 1347, 1348, 5, 443, 0, 0, 1348, 1374, 5, 456, 0, 0, 1349, 1350, 5, 443, 0, 0, 1350, 1351, 5, 464, 0, 0, 1351, 1356, 5, 482, 0, 0, 1352, 1353, 5, 462, 0, 0, 1353, 1355, 5, 482, 0, 0, 1354, 1352, 1, 0, 0, 0, 1355, 1358, 1, 0, 0, 0, 1356, 1354, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 1359, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1359, 1374, 5, 465, 0, 0, 1360, 1361, 5, 444, 0, 0, 1361, 1374, 5, 456, 0, 0, 1362, 1363, 5, 444, 0, 0, 1363, 1364, 5, 464, 0, 0, 1364, 1369, 5, 482, 0, 0, 1365, 1366, 5, 462, 0, 0, 1366, 1368, 5, 482, 0, 0, 1367, 1365, 1, 0, 0, 0, 1368, 1371, 1, 0, 0, 0, 1369, 1367, 1, 0, 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 1372, 1, 0, 0, 0, 1371, 1369, 1, 0, 0, 0, 1372, 1374, 5, 465, 0, 0, 1373, 1345, 1, 0, 0, 0, 1373, 1346, 1, 0, 0, 0, 1373, 1347, 1, 0, 0, 0, 1373, 1349, 1, 0, 0, 0, 1373, 1360, 1, 0, 0, 0, 1373, 1362, 1, 0, 0, 0, 1374, 79, 1, 0, 0, 0, 1375, 1376, 5, 24, 0, 0, 1376, 1377, 5, 23, 0, 0, 1377, 1379, 3, 646, 323, 0, 1378, 1380, 3, 82, 41, 0, 1379, 1378, 1, 0, 0, 0, 1379, 1380, 1, 0, 0, 0, 1380, 1382, 1, 0, 0, 0, 1381, 1383, 3, 84, 42, 0, 1382, 1381, 1, 0, 0, 0, 1382, 1383, 1, 0, 0, 0, 1383, 1422, 1, 0, 0, 0, 1384, 1385, 5, 11, 0, 0, 1385, 1386, 5, 23, 0, 0, 1386, 1388, 3, 646, 323, 0, 1387, 1389, 3, 82, 41, 0, 1388, 1387, 1, 0, 0, 0, 1388, 1389, 1, 0, 0, 0, 1389, 1391, 1, 0, 0, 0, 1390, 1392, 3, 84, 42, 0, 1391, 1390, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 1422, 1, 0, 0, 0, 1393, 1394, 5, 25, 0, 0, 1394, 1395, 5, 23, 0, 0, 1395, 1397, 3, 646, 323, 0, 1396, 1398, 3, 84, 42, 0, 1397, 1396, 1, 0, 0, 0, 1397, 1398, 1, 0, 0, 0, 1398, 1399, 1, 0, 0, 0, 1399, 1401, 5, 75, 0, 0, 1400, 1402, 5, 464, 0, 0, 1401, 1400, 1, 0, 0, 0, 1401, 1402, 1, 0, 0, 0, 1402, 1403, 1, 0, 0, 0, 1403, 1405, 3, 522, 261, 0, 1404, 1406, 5, 465, 0, 0, 1405, 1404, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1422, 1, 0, 0, 0, 1407, 1408, 5, 26, 0, 0, 1408, 1409, 5, 23, 0, 0, 1409, 1411, 3, 646, 323, 0, 1410, 1412, 3, 84, 42, 0, 1411, 1410, 1, 0, 0, 0, 1411, 1412, 1, 0, 0, 0, 1412, 1422, 1, 0, 0, 0, 1413, 1414, 5, 23, 0, 0, 1414, 1416, 3, 646, 323, 0, 1415, 1417, 3, 82, 41, 0, 1416, 1415, 1, 0, 0, 0, 1416, 1417, 1, 0, 0, 0, 1417, 1419, 1, 0, 0, 0, 1418, 1420, 3, 84, 42, 0, 1419, 1418, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1422, 1, 0, 0, 0, 1421, 1375, 1, 0, 0, 0, 1421, 1384, 1, 0, 0, 0, 1421, 1393, 1, 0, 0, 0, 1421, 1407, 1, 0, 0, 0, 1421, 1413, 1, 0, 0, 0, 1422, 81, 1, 0, 0, 0, 1423, 1424, 5, 45, 0, 0, 1424, 1428, 3, 646, 323, 0, 1425, 1426, 5, 44, 0, 0, 1426, 1428, 3, 646, 323, 0, 1427, 1423, 1, 0, 0, 0, 1427, 1425, 1, 0, 0, 0, 1428, 83, 1, 0, 0, 0, 1429, 1431, 5, 464, 0, 0, 1430, 1432, 3, 90, 45, 0, 1431, 1430, 1, 0, 0, 0, 1431, 1432, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1435, 5, 465, 0, 0, 1434, 1436, 3, 86, 43, 0, 1435, 1434, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 1436, 1439, 1, 0, 0, 0, 1437, 1439, 3, 86, 43, 0, 1438, 1429, 1, 0, 0, 0, 1438, 1437, 1, 0, 0, 0, 1439, 85, 1, 0, 0, 0, 1440, 1447, 3, 88, 44, 0, 1441, 1443, 5, 462, 0, 0, 1442, 1441, 1, 0, 0, 0, 1442, 1443, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 1446, 3, 88, 44, 0, 1445, 1442, 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447, 1445, 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, 87, 1, 0, 0, 0, 1449, 1447, 1, 0, 0, 0, 1450, 1451, 5, 393, 0, 0, 1451, 1455, 5, 478, 0, 0, 1452, 1453, 5, 41, 0, 0, 1453, 1455, 3, 104, 52, 0, 1454, 1450, 1, 0, 0, 0, 1454, 1452, 1, 0, 0, 0, 1455, 89, 1, 0, 0, 0, 1456, 1461, 3, 92, 46, 0, 1457, 1458, 5, 462, 0, 0, 1458, 1460, 3, 92, 46, 0, 1459, 1457, 1, 0, 0, 0, 1460, 1463, 1, 0, 0, 0, 1461, 1459, 1, 0, 0, 0, 1461, 1462, 1, 0, 0, 0, 1462, 91, 1, 0, 0, 0, 1463, 1461, 1, 0, 0, 0, 1464, 1466, 3, 656, 328, 0, 1465, 1464, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1470, 1, 0, 0, 0, 1467, 1469, 3, 658, 329, 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, 1474, 3, 94, 47, 0, 1474, 1475, 5, 470, 0, 0, 1475, 1479, 3, 98, 49, 0, 1476, 1478, 3, 96, 48, 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, 93, 1, 0, 0, 0, 1481, 1479, 1, 0, 0, 0, 1482, 1486, 5, 482, 0, 0, 1483, 1486, 5, 484, 0, 0, 1484, 1486, 3, 668, 334, 0, 1485, 1482, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1484, 1, 0, 0, 0, 1486, 95, 1, 0, 0, 0, 1487, 1490, 5, 7, 0, 0, 1488, 1489, 5, 297, 0, 0, 1489, 1491, 5, 478, 0, 0, 1490, 1488, 1, 0, 0, 0, 1490, 1491, 1, 0, 0, 0, 1491, 1514, 1, 0, 0, 0, 1492, 1493, 5, 282, 0, 0, 1493, 1496, 5, 283, 0, 0, 1494, 1495, 5, 297, 0, 0, 1495, 1497, 5, 478, 0, 0, 1496, 1494, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, 1514, 1, 0, 0, 0, 1498, 1501, 5, 289, 0, 0, 1499, 1500, 5, 297, 0, 0, 1500, 1502, 5, 478, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1514, 1, 0, 0, 0, 1503, 1506, 5, 290, 0, 0, 1504, 1507, 3, 650, 325, 0, 1505, 1507, 3, 608, 304, 0, 1506, 1504, 1, 0, 0, 0, 1506, 1505, 1, 0, 0, 0, 1507, 1514, 1, 0, 0, 0, 1508, 1511, 5, 296, 0, 0, 1509, 1510, 5, 297, 0, 0, 1510, 1512, 5, 478, 0, 0, 1511, 1509, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1514, 1, 0, 0, 0, 1513, 1487, 1, 0, 0, 0, 1513, 1492, 1, 0, 0, 0, 1513, 1498, 1, 0, 0, 0, 1513, 1503, 1, 0, 0, 0, 1513, 1508, 1, 0, 0, 0, 1514, 97, 1, 0, 0, 0, 1515, 1519, 5, 257, 0, 0, 1516, 1517, 5, 464, 0, 0, 1517, 1518, 5, 480, 0, 0, 1518, 1520, 5, 465, 0, 0, 1519, 1516, 1, 0, 0, 0, 1519, 1520, 1, 0, 0, 0, 1520, 1552, 1, 0, 0, 0, 1521, 1552, 5, 258, 0, 0, 1522, 1552, 5, 259, 0, 0, 1523, 1552, 5, 260, 0, 0, 1524, 1552, 5, 261, 0, 0, 1525, 1552, 5, 262, 0, 0, 1526, 1552, 5, 263, 0, 0, 1527, 1552, 5, 264, 0, 0, 1528, 1552, 5, 265, 0, 0, 1529, 1552, 5, 266, 0, 0, 1530, 1552, 5, 267, 0, 0, 1531, 1552, 5, 268, 0, 0, 1532, 1533, 5, 269, 0, 0, 1533, 1534, 5, 464, 0, 0, 1534, 1535, 3, 100, 50, 0, 1535, 1536, 5, 465, 0, 0, 1536, 1552, 1, 0, 0, 0, 1537, 1538, 5, 23, 0, 0, 1538, 1539, 5, 452, 0, 0, 1539, 1540, 5, 482, 0, 0, 1540, 1552, 5, 453, 0, 0, 1541, 1542, 5, 270, 0, 0, 1542, 1552, 3, 646, 323, 0, 1543, 1544, 5, 28, 0, 0, 1544, 1545, 5, 464, 0, 0, 1545, 1546, 3, 646, 323, 0, 1546, 1547, 5, 465, 0, 0, 1547, 1552, 1, 0, 0, 0, 1548, 1549, 5, 13, 0, 0, 1549, 1552, 3, 646, 323, 0, 1550, 1552, 3, 646, 323, 0, 1551, 1515, 1, 0, 0, 0, 1551, 1521, 1, 0, 0, 0, 1551, 1522, 1, 0, 0, 0, 1551, 1523, 1, 0, 0, 0, 1551, 1524, 1, 0, 0, 0, 1551, 1525, 1, 0, 0, 0, 1551, 1526, 1, 0, 0, 0, 1551, 1527, 1, 0, 0, 0, 1551, 1528, 1, 0, 0, 0, 1551, 1529, 1, 0, 0, 0, 1551, 1530, 1, 0, 0, 0, 1551, 1531, 1, 0, 0, 0, 1551, 1532, 1, 0, 0, 0, 1551, 1537, 1, 0, 0, 0, 1551, 1541, 1, 0, 0, 0, 1551, 1543, 1, 0, 0, 0, 1551, 1548, 1, 0, 0, 0, 1551, 1550, 1, 0, 0, 0, 1552, 99, 1, 0, 0, 0, 1553, 1554, 7, 5, 0, 0, 1554, 101, 1, 0, 0, 0, 1555, 1559, 5, 257, 0, 0, 1556, 1557, 5, 464, 0, 0, 1557, 1558, 5, 480, 0, 0, 1558, 1560, 5, 465, 0, 0, 1559, 1556, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 1581, 1, 0, 0, 0, 1561, 1581, 5, 258, 0, 0, 1562, 1581, 5, 259, 0, 0, 1563, 1581, 5, 260, 0, 0, 1564, 1581, 5, 261, 0, 0, 1565, 1581, 5, 262, 0, 0, 1566, 1581, 5, 263, 0, 0, 1567, 1581, 5, 264, 0, 0, 1568, 1581, 5, 265, 0, 0, 1569, 1581, 5, 266, 0, 0, 1570, 1581, 5, 267, 0, 0, 1571, 1581, 5, 268, 0, 0, 1572, 1573, 5, 270, 0, 0, 1573, 1581, 3, 646, 323, 0, 1574, 1575, 5, 28, 0, 0, 1575, 1576, 5, 464, 0, 0, 1576, 1577, 3, 646, 323, 0, 1577, 1578, 5, 465, 0, 0, 1578, 1581, 1, 0, 0, 0, 1579, 1581, 3, 646, 323, 0, 1580, 1555, 1, 0, 0, 0, 1580, 1561, 1, 0, 0, 0, 1580, 1562, 1, 0, 0, 0, 1580, 1563, 1, 0, 0, 0, 1580, 1564, 1, 0, 0, 0, 1580, 1565, 1, 0, 0, 0, 1580, 1566, 1, 0, 0, 0, 1580, 1567, 1, 0, 0, 0, 1580, 1568, 1, 0, 0, 0, 1580, 1569, 1, 0, 0, 0, 1580, 1570, 1, 0, 0, 0, 1580, 1571, 1, 0, 0, 0, 1580, 1572, 1, 0, 0, 0, 1580, 1574, 1, 0, 0, 0, 1580, 1579, 1, 0, 0, 0, 1581, 103, 1, 0, 0, 0, 1582, 1584, 5, 482, 0, 0, 1583, 1582, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 5, 464, 0, 0, 1586, 1587, 3, 106, 53, 0, 1587, 1588, 5, 465, 0, 0, 1588, 105, 1, 0, 0, 0, 1589, 1594, 3, 108, 54, 0, 1590, 1591, 5, 462, 0, 0, 1591, 1593, 3, 108, 54, 0, 1592, 1590, 1, 0, 0, 0, 1593, 1596, 1, 0, 0, 0, 1594, 1592, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 107, 1, 0, 0, 0, 1596, 1594, 1, 0, 0, 0, 1597, 1599, 3, 110, 55, 0, 1598, 1600, 7, 6, 0, 0, 1599, 1598, 1, 0, 0, 0, 1599, 1600, 1, 0, 0, 0, 1600, 109, 1, 0, 0, 0, 1601, 1605, 5, 482, 0, 0, 1602, 1605, 5, 484, 0, 0, 1603, 1605, 3, 668, 334, 0, 1604, 1601, 1, 0, 0, 0, 1604, 1602, 1, 0, 0, 0, 1604, 1603, 1, 0, 0, 0, 1605, 111, 1, 0, 0, 0, 1606, 1607, 5, 27, 0, 0, 1607, 1608, 3, 646, 323, 0, 1608, 1609, 5, 70, 0, 0, 1609, 1610, 3, 646, 323, 0, 1610, 1611, 5, 410, 0, 0, 1611, 1613, 3, 646, 323, 0, 1612, 1614, 3, 114, 57, 0, 1613, 1612, 1, 0, 0, 0, 1613, 1614, 1, 0, 0, 0, 1614, 113, 1, 0, 0, 0, 1615, 1617, 3, 116, 58, 0, 1616, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1616, 1, 0, 0, 0, 1618, 1619, 1, 0, 0, 0, 1619, 115, 1, 0, 0, 0, 1620, 1621, 5, 404, 0, 0, 1621, 1631, 7, 7, 0, 0, 1622, 1623, 5, 42, 0, 0, 1623, 1631, 7, 8, 0, 0, 1624, 1625, 5, 50, 0, 0, 1625, 1631, 7, 9, 0, 0, 1626, 1627, 5, 52, 0, 0, 1627, 1631, 3, 118, 59, 0, 1628, 1629, 5, 393, 0, 0, 1629, 1631, 5, 478, 0, 0, 1630, 1620, 1, 0, 0, 0, 1630, 1622, 1, 0, 0, 0, 1630, 1624, 1, 0, 0, 0, 1630, 1626, 1, 0, 0, 0, 1630, 1628, 1, 0, 0, 0, 1631, 117, 1, 0, 0, 0, 1632, 1633, 7, 10, 0, 0, 1633, 119, 1, 0, 0, 0, 1634, 1635, 5, 46, 0, 0, 1635, 1636, 5, 38, 0, 0, 1636, 1691, 3, 92, 46, 0, 1637, 1638, 5, 46, 0, 0, 1638, 1639, 5, 39, 0, 0, 1639, 1691, 3, 92, 46, 0, 1640, 1641, 5, 20, 0, 0, 1641, 1642, 5, 38, 0, 0, 1642, 1643, 3, 94, 47, 0, 1643, 1644, 5, 410, 0, 0, 1644, 1645, 3, 94, 47, 0, 1645, 1691, 1, 0, 0, 0, 1646, 1647, 5, 20, 0, 0, 1647, 1648, 5, 39, 0, 0, 1648, 1649, 3, 94, 47, 0, 1649, 1650, 5, 410, 0, 0, 1650, 1651, 3, 94, 47, 0, 1651, 1691, 1, 0, 0, 0, 1652, 1653, 5, 22, 0, 0, 1653, 1654, 5, 38, 0, 0, 1654, 1655, 3, 94, 47, 0, 1655, 1659, 3, 98, 49, 0, 1656, 1658, 3, 96, 48, 0, 1657, 1656, 1, 0, 0, 0, 1658, 1661, 1, 0, 0, 0, 1659, 1657, 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0, 1660, 1691, 1, 0, 0, 0, 1661, 1659, 1, 0, 0, 0, 1662, 1663, 5, 22, 0, 0, 1663, 1664, 5, 39, 0, 0, 1664, 1665, 3, 94, 47, 0, 1665, 1669, 3, 98, 49, 0, 1666, 1668, 3, 96, 48, 0, 1667, 1666, 1, 0, 0, 0, 1668, 1671, 1, 0, 0, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, 1691, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1673, 5, 19, 0, 0, 1673, 1674, 5, 38, 0, 0, 1674, 1691, 3, 94, 47, 0, 1675, 1676, 5, 19, 0, 0, 1676, 1677, 5, 39, 0, 0, 1677, 1691, 3, 94, 47, 0, 1678, 1679, 5, 47, 0, 0, 1679, 1680, 5, 49, 0, 0, 1680, 1691, 5, 478, 0, 0, 1681, 1682, 5, 47, 0, 0, 1682, 1683, 5, 393, 0, 0, 1683, 1691, 5, 478, 0, 0, 1684, 1685, 5, 46, 0, 0, 1685, 1686, 5, 41, 0, 0, 1686, 1691, 3, 104, 52, 0, 1687, 1688, 5, 19, 0, 0, 1688, 1689, 5, 41, 0, 0, 1689, 1691, 5, 482, 0, 0, 1690, 1634, 1, 0, 0, 0, 1690, 1637, 1, 0, 0, 0, 1690, 1640, 1, 0, 0, 0, 1690, 1646, 1, 0, 0, 0, 1690, 1652, 1, 0, 0, 0, 1690, 1662, 1, 0, 0, 0, 1690, 1672, 1, 0, 0, 0, 1690, 1675, 1, 0, 0, 0, 1690, 1678, 1, 0, 0, 0, 1690, 1681, 1, 0, 0, 0, 1690, 1684, 1, 0, 0, 0, 1690, 1687, 1, 0, 0, 0, 1691, 121, 1, 0, 0, 0, 1692, 1693, 5, 47, 0, 0, 1693, 1694, 5, 52, 0, 0, 1694, 1705, 3, 118, 59, 0, 1695, 1696, 5, 47, 0, 0, 1696, 1697, 5, 42, 0, 0, 1697, 1705, 7, 8, 0, 0, 1698, 1699, 5, 47, 0, 0, 1699, 1700, 5, 50, 0, 0, 1700, 1705, 7, 9, 0, 0, 1701, 1702, 5, 47, 0, 0, 1702, 1703, 5, 393, 0, 0, 1703, 1705, 5, 478, 0, 0, 1704, 1692, 1, 0, 0, 0, 1704, 1695, 1, 0, 0, 0, 1704, 1698, 1, 0, 0, 0, 1704, 1701, 1, 0, 0, 0, 1705, 123, 1, 0, 0, 0, 1706, 1707, 5, 46, 0, 0, 1707, 1708, 5, 405, 0, 0, 1708, 1711, 5, 482, 0, 0, 1709, 1710, 5, 186, 0, 0, 1710, 1712, 5, 478, 0, 0, 1711, 1709, 1, 0, 0, 0, 1711, 1712, 1, 0, 0, 0, 1712, 1725, 1, 0, 0, 0, 1713, 1714, 5, 20, 0, 0, 1714, 1715, 5, 405, 0, 0, 1715, 1716, 5, 482, 0, 0, 1716, 1717, 5, 410, 0, 0, 1717, 1725, 5, 482, 0, 0, 1718, 1719, 5, 19, 0, 0, 1719, 1720, 5, 405, 0, 0, 1720, 1725, 5, 482, 0, 0, 1721, 1722, 5, 47, 0, 0, 1722, 1723, 5, 393, 0, 0, 1723, 1725, 5, 478, 0, 0, 1724, 1706, 1, 0, 0, 0, 1724, 1713, 1, 0, 0, 0, 1724, 1718, 1, 0, 0, 0, 1724, 1721, 1, 0, 0, 0, 1725, 125, 1, 0, 0, 0, 1726, 1727, 5, 46, 0, 0, 1727, 1728, 5, 33, 0, 0, 1728, 1731, 3, 646, 323, 0, 1729, 1730, 5, 48, 0, 0, 1730, 1732, 5, 480, 0, 0, 1731, 1729, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, 1740, 1, 0, 0, 0, 1733, 1734, 5, 19, 0, 0, 1734, 1735, 5, 33, 0, 0, 1735, 1740, 3, 646, 323, 0, 1736, 1737, 5, 47, 0, 0, 1737, 1738, 5, 393, 0, 0, 1738, 1740, 5, 478, 0, 0, 1739, 1726, 1, 0, 0, 0, 1739, 1733, 1, 0, 0, 0, 1739, 1736, 1, 0, 0, 0, 1740, 127, 1, 0, 0, 0, 1741, 1742, 5, 29, 0, 0, 1742, 1744, 5, 482, 0, 0, 1743, 1745, 3, 130, 65, 0, 1744, 1743, 1, 0, 0, 0, 1744, 1745, 1, 0, 0, 0, 1745, 129, 1, 0, 0, 0, 1746, 1748, 3, 132, 66, 0, 1747, 1746, 1, 0, 0, 0, 1748, 1749, 1, 0, 0, 0, 1749, 1747, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 131, 1, 0, 0, 0, 1751, 1752, 5, 393, 0, 0, 1752, 1756, 5, 478, 0, 0, 1753, 1754, 5, 215, 0, 0, 1754, 1756, 5, 478, 0, 0, 1755, 1751, 1, 0, 0, 0, 1755, 1753, 1, 0, 0, 0, 1756, 133, 1, 0, 0, 0, 1757, 1758, 5, 28, 0, 0, 1758, 1759, 3, 646, 323, 0, 1759, 1760, 5, 464, 0, 0, 1760, 1761, 3, 136, 68, 0, 1761, 1763, 5, 465, 0, 0, 1762, 1764, 3, 142, 71, 0, 1763, 1762, 1, 0, 0, 0, 1763, 1764, 1, 0, 0, 0, 1764, 135, 1, 0, 0, 0, 1765, 1770, 3, 138, 69, 0, 1766, 1767, 5, 462, 0, 0, 1767, 1769, 3, 138, 69, 0, 1768, 1766, 1, 0, 0, 0, 1769, 1772, 1, 0, 0, 0, 1770, 1768, 1, 0, 0, 0, 1770, 1771, 1, 0, 0, 0, 1771, 137, 1, 0, 0, 0, 1772, 1770, 1, 0, 0, 0, 1773, 1775, 3, 656, 328, 0, 1774, 1773, 1, 0, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1781, 3, 140, 70, 0, 1777, 1779, 5, 186, 0, 0, 1778, 1777, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1780, 1, 0, 0, 0, 1780, 1782, 5, 478, 0, 0, 1781, 1778, 1, 0, 0, 0, 1781, 1782, 1, 0, 0, 0, 1782, 139, 1, 0, 0, 0, 1783, 1799, 5, 482, 0, 0, 1784, 1799, 5, 484, 0, 0, 1785, 1799, 3, 668, 334, 0, 1786, 1799, 5, 306, 0, 0, 1787, 1799, 5, 307, 0, 0, 1788, 1799, 5, 337, 0, 0, 1789, 1799, 5, 336, 0, 0, 1790, 1799, 5, 312, 0, 0, 1791, 1799, 5, 331, 0, 0, 1792, 1799, 5, 332, 0, 0, 1793, 1799, 5, 333, 0, 0, 1794, 1799, 5, 334, 0, 0, 1795, 1799, 5, 26, 0, 0, 1796, 1799, 5, 338, 0, 0, 1797, 1799, 5, 360, 0, 0, 1798, 1783, 1, 0, 0, 0, 1798, 1784, 1, 0, 0, 0, 1798, 1785, 1, 0, 0, 0, 1798, 1786, 1, 0, 0, 0, 1798, 1787, 1, 0, 0, 0, 1798, 1788, 1, 0, 0, 0, 1798, 1789, 1, 0, 0, 0, 1798, 1790, 1, 0, 0, 0, 1798, 1791, 1, 0, 0, 0, 1798, 1792, 1, 0, 0, 0, 1798, 1793, 1, 0, 0, 0, 1798, 1794, 1, 0, 0, 0, 1798, 1795, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1798, 1797, 1, 0, 0, 0, 1799, 141, 1, 0, 0, 0, 1800, 1802, 3, 144, 72, 0, 1801, 1800, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1801, 1, 0, 0, 0, 1803, 1804, 1, 0, 0, 0, 1804, 143, 1, 0, 0, 0, 1805, 1806, 5, 393, 0, 0, 1806, 1807, 5, 478, 0, 0, 1807, 145, 1, 0, 0, 0, 1808, 1809, 5, 293, 0, 0, 1809, 1810, 5, 295, 0, 0, 1810, 1811, 3, 646, 323, 0, 1811, 1812, 5, 413, 0, 0, 1812, 1813, 3, 646, 323, 0, 1813, 1814, 3, 148, 74, 0, 1814, 147, 1, 0, 0, 0, 1815, 1816, 5, 302, 0, 0, 1816, 1817, 3, 608, 304, 0, 1817, 1818, 5, 294, 0, 0, 1818, 1819, 5, 478, 0, 0, 1819, 1843, 1, 0, 0, 0, 1820, 1821, 5, 296, 0, 0, 1821, 1822, 3, 152, 76, 0, 1822, 1823, 5, 294, 0, 0, 1823, 1824, 5, 478, 0, 0, 1824, 1843, 1, 0, 0, 0, 1825, 1826, 5, 289, 0, 0, 1826, 1827, 3, 154, 77, 0, 1827, 1828, 5, 294, 0, 0, 1828, 1829, 5, 478, 0, 0, 1829, 1843, 1, 0, 0, 0, 1830, 1831, 5, 299, 0, 0, 1831, 1832, 3, 152, 76, 0, 1832, 1833, 3, 150, 75, 0, 1833, 1834, 5, 294, 0, 0, 1834, 1835, 5, 478, 0, 0, 1835, 1843, 1, 0, 0, 0, 1836, 1837, 5, 300, 0, 0, 1837, 1838, 3, 152, 76, 0, 1838, 1839, 5, 478, 0, 0, 1839, 1840, 5, 294, 0, 0, 1840, 1841, 5, 478, 0, 0, 1841, 1843, 1, 0, 0, 0, 1842, 1815, 1, 0, 0, 0, 1842, 1820, 1, 0, 0, 0, 1842, 1825, 1, 0, 0, 0, 1842, 1830, 1, 0, 0, 0, 1842, 1836, 1, 0, 0, 0, 1843, 149, 1, 0, 0, 0, 1844, 1845, 5, 285, 0, 0, 1845, 1846, 3, 650, 325, 0, 1846, 1847, 5, 280, 0, 0, 1847, 1848, 3, 650, 325, 0, 1848, 1858, 1, 0, 0, 0, 1849, 1850, 5, 452, 0, 0, 1850, 1858, 3, 650, 325, 0, 1851, 1852, 5, 449, 0, 0, 1852, 1858, 3, 650, 325, 0, 1853, 1854, 5, 453, 0, 0, 1854, 1858, 3, 650, 325, 0, 1855, 1856, 5, 450, 0, 0, 1856, 1858, 3, 650, 325, 0, 1857, 1844, 1, 0, 0, 0, 1857, 1849, 1, 0, 0, 0, 1857, 1851, 1, 0, 0, 0, 1857, 1853, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1858, 151, 1, 0, 0, 0, 1859, 1864, 5, 482, 0, 0, 1860, 1861, 5, 457, 0, 0, 1861, 1863, 5, 482, 0, 0, 1862, 1860, 1, 0, 0, 0, 1863, 1866, 1, 0, 0, 0, 1864, 1862, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 153, 1, 0, 0, 0, 1866, 1864, 1, 0, 0, 0, 1867, 1872, 3, 152, 76, 0, 1868, 1869, 5, 462, 0, 0, 1869, 1871, 3, 152, 76, 0, 1870, 1868, 1, 0, 0, 0, 1871, 1874, 1, 0, 0, 0, 1872, 1870, 1, 0, 0, 0, 1872, 1873, 1, 0, 0, 0, 1873, 155, 1, 0, 0, 0, 1874, 1872, 1, 0, 0, 0, 1875, 1876, 5, 30, 0, 0, 1876, 1877, 3, 646, 323, 0, 1877, 1879, 5, 464, 0, 0, 1878, 1880, 3, 168, 84, 0, 1879, 1878, 1, 0, 0, 0, 1879, 1880, 1, 0, 0, 0, 1880, 1881, 1, 0, 0, 0, 1881, 1883, 5, 465, 0, 0, 1882, 1884, 3, 174, 87, 0, 1883, 1882, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 1886, 1, 0, 0, 0, 1885, 1887, 3, 176, 88, 0, 1886, 1885, 1, 0, 0, 0, 1886, 1887, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1889, 5, 95, 0, 0, 1889, 1890, 3, 180, 90, 0, 1890, 1892, 5, 82, 0, 0, 1891, 1893, 5, 461, 0, 0, 1892, 1891, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1896, 5, 457, 0, 0, 1895, 1894, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 157, 1, 0, 0, 0, 1897, 1898, 5, 113, 0, 0, 1898, 1899, 5, 114, 0, 0, 1899, 1900, 3, 646, 323, 0, 1900, 1902, 5, 464, 0, 0, 1901, 1903, 3, 160, 80, 0, 1902, 1901, 1, 0, 0, 0, 1902, 1903, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 1906, 5, 465, 0, 0, 1905, 1907, 3, 164, 82, 0, 1906, 1905, 1, 0, 0, 0, 1906, 1907, 1, 0, 0, 0, 1907, 1909, 1, 0, 0, 0, 1908, 1910, 3, 166, 83, 0, 1909, 1908, 1, 0, 0, 0, 1909, 1910, 1, 0, 0, 0, 1910, 1911, 1, 0, 0, 0, 1911, 1912, 5, 75, 0, 0, 1912, 1914, 5, 479, 0, 0, 1913, 1915, 5, 461, 0, 0, 1914, 1913, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 159, 1, 0, 0, 0, 1916, 1921, 3, 162, 81, 0, 1917, 1918, 5, 462, 0, 0, 1918, 1920, 3, 162, 81, 0, 1919, 1917, 1, 0, 0, 0, 1920, 1923, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1921, 1922, 1, 0, 0, 0, 1922, 161, 1, 0, 0, 0, 1923, 1921, 1, 0, 0, 0, 1924, 1925, 3, 172, 86, 0, 1925, 1926, 5, 470, 0, 0, 1926, 1928, 3, 98, 49, 0, 1927, 1929, 5, 7, 0, 0, 1928, 1927, 1, 0, 0, 0, 1928, 1929, 1, 0, 0, 0, 1929, 163, 1, 0, 0, 0, 1930, 1931, 5, 76, 0, 0, 1931, 1932, 3, 98, 49, 0, 1932, 165, 1, 0, 0, 0, 1933, 1934, 5, 357, 0, 0, 1934, 1935, 5, 75, 0, 0, 1935, 1936, 5, 478, 0, 0, 1936, 1937, 5, 284, 0, 0, 1937, 1938, 5, 478, 0, 0, 1938, 167, 1, 0, 0, 0, 1939, 1944, 3, 170, 85, 0, 1940, 1941, 5, 462, 0, 0, 1941, 1943, 3, 170, 85, 0, 1942, 1940, 1, 0, 0, 0, 1943, 1946, 1, 0, 0, 0, 1944, 1942, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 169, 1, 0, 0, 0, 1946, 1944, 1, 0, 0, 0, 1947, 1950, 3, 172, 86, 0, 1948, 1950, 5, 481, 0, 0, 1949, 1947, 1, 0, 0, 0, 1949, 1948, 1, 0, 0, 0, 1950, 1951, 1, 0, 0, 0, 1951, 1952, 5, 470, 0, 0, 1952, 1953, 3, 98, 49, 0, 1953, 171, 1, 0, 0, 0, 1954, 1958, 5, 482, 0, 0, 1955, 1958, 5, 484, 0, 0, 1956, 1958, 3, 668, 334, 0, 1957, 1954, 1, 0, 0, 0, 1957, 1955, 1, 0, 0, 0, 1957, 1956, 1, 0, 0, 0, 1958, 173, 1, 0, 0, 0, 1959, 1960, 5, 76, 0, 0, 1960, 1963, 3, 98, 49, 0, 1961, 1962, 5, 75, 0, 0, 1962, 1964, 5, 481, 0, 0, 1963, 1961, 1, 0, 0, 0, 1963, 1964, 1, 0, 0, 0, 1964, 175, 1, 0, 0, 0, 1965, 1967, 3, 178, 89, 0, 1966, 1965, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 1966, 1, 0, 0, 0, 1968, 1969, 1, 0, 0, 0, 1969, 177, 1, 0, 0, 0, 1970, 1971, 5, 215, 0, 0, 1971, 1975, 5, 478, 0, 0, 1972, 1973, 5, 393, 0, 0, 1973, 1975, 5, 478, 0, 0, 1974, 1970, 1, 0, 0, 0, 1974, 1972, 1, 0, 0, 0, 1975, 179, 1, 0, 0, 0, 1976, 1978, 3, 182, 91, 0, 1977, 1976, 1, 0, 0, 0, 1978, 1981, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 181, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1982, 1984, 3, 658, 329, 0, 1983, 1982, 1, 0, 0, 0, 1984, 1987, 1, 0, 0, 0, 1985, 1983, 1, 0, 0, 0, 1985, 1986, 1, 0, 0, 0, 1986, 1988, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, 0, 1988, 1990, 3, 184, 92, 0, 1989, 1991, 5, 461, 0, 0, 1990, 1989, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 2303, 1, 0, 0, 0, 1992, 1994, 3, 658, 329, 0, 1993, 1992, 1, 0, 0, 0, 1994, 1997, 1, 0, 0, 0, 1995, 1993, 1, 0, 0, 0, 1995, 1996, 1, 0, 0, 0, 1996, 1998, 1, 0, 0, 0, 1997, 1995, 1, 0, 0, 0, 1998, 2000, 3, 186, 93, 0, 1999, 2001, 5, 461, 0, 0, 2000, 1999, 1, 0, 0, 0, 2000, 2001, 1, 0, 0, 0, 2001, 2303, 1, 0, 0, 0, 2002, 2004, 3, 658, 329, 0, 2003, 2002, 1, 0, 0, 0, 2004, 2007, 1, 0, 0, 0, 2005, 2003, 1, 0, 0, 0, 2005, 2006, 1, 0, 0, 0, 2006, 2008, 1, 0, 0, 0, 2007, 2005, 1, 0, 0, 0, 2008, 2010, 3, 290, 145, 0, 2009, 2011, 5, 461, 0, 0, 2010, 2009, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2303, 1, 0, 0, 0, 2012, 2014, 3, 658, 329, 0, 2013, 2012, 1, 0, 0, 0, 2014, 2017, 1, 0, 0, 0, 2015, 2013, 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 2018, 1, 0, 0, 0, 2017, 2015, 1, 0, 0, 0, 2018, 2020, 3, 188, 94, 0, 2019, 2021, 5, 461, 0, 0, 2020, 2019, 1, 0, 0, 0, 2020, 2021, 1, 0, 0, 0, 2021, 2303, 1, 0, 0, 0, 2022, 2024, 3, 658, 329, 0, 2023, 2022, 1, 0, 0, 0, 2024, 2027, 1, 0, 0, 0, 2025, 2023, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2028, 1, 0, 0, 0, 2027, 2025, 1, 0, 0, 0, 2028, 2030, 3, 190, 95, 0, 2029, 2031, 5, 461, 0, 0, 2030, 2029, 1, 0, 0, 0, 2030, 2031, 1, 0, 0, 0, 2031, 2303, 1, 0, 0, 0, 2032, 2034, 3, 658, 329, 0, 2033, 2032, 1, 0, 0, 0, 2034, 2037, 1, 0, 0, 0, 2035, 2033, 1, 0, 0, 0, 2035, 2036, 1, 0, 0, 0, 2036, 2038, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2038, 2040, 3, 194, 97, 0, 2039, 2041, 5, 461, 0, 0, 2040, 2039, 1, 0, 0, 0, 2040, 2041, 1, 0, 0, 0, 2041, 2303, 1, 0, 0, 0, 2042, 2044, 3, 658, 329, 0, 2043, 2042, 1, 0, 0, 0, 2044, 2047, 1, 0, 0, 0, 2045, 2043, 1, 0, 0, 0, 2045, 2046, 1, 0, 0, 0, 2046, 2048, 1, 0, 0, 0, 2047, 2045, 1, 0, 0, 0, 2048, 2050, 3, 196, 98, 0, 2049, 2051, 5, 461, 0, 0, 2050, 2049, 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, 2303, 1, 0, 0, 0, 2052, 2054, 3, 658, 329, 0, 2053, 2052, 1, 0, 0, 0, 2054, 2057, 1, 0, 0, 0, 2055, 2053, 1, 0, 0, 0, 2055, 2056, 1, 0, 0, 0, 2056, 2058, 1, 0, 0, 0, 2057, 2055, 1, 0, 0, 0, 2058, 2060, 3, 198, 99, 0, 2059, 2061, 5, 461, 0, 0, 2060, 2059, 1, 0, 0, 0, 2060, 2061, 1, 0, 0, 0, 2061, 2303, 1, 0, 0, 0, 2062, 2064, 3, 658, 329, 0, 2063, 2062, 1, 0, 0, 0, 2064, 2067, 1, 0, 0, 0, 2065, 2063, 1, 0, 0, 0, 2065, 2066, 1, 0, 0, 0, 2066, 2068, 1, 0, 0, 0, 2067, 2065, 1, 0, 0, 0, 2068, 2070, 3, 200, 100, 0, 2069, 2071, 5, 461, 0, 0, 2070, 2069, 1, 0, 0, 0, 2070, 2071, 1, 0, 0, 0, 2071, 2303, 1, 0, 0, 0, 2072, 2074, 3, 658, 329, 0, 2073, 2072, 1, 0, 0, 0, 2074, 2077, 1, 0, 0, 0, 2075, 2073, 1, 0, 0, 0, 2075, 2076, 1, 0, 0, 0, 2076, 2078, 1, 0, 0, 0, 2077, 2075, 1, 0, 0, 0, 2078, 2080, 3, 206, 103, 0, 2079, 2081, 5, 461, 0, 0, 2080, 2079, 1, 0, 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2303, 1, 0, 0, 0, 2082, 2084, 3, 658, 329, 0, 2083, 2082, 1, 0, 0, 0, 2084, 2087, 1, 0, 0, 0, 2085, 2083, 1, 0, 0, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2088, 1, 0, 0, 0, 2087, 2085, 1, 0, 0, 0, 2088, 2090, 3, 208, 104, 0, 2089, 2091, 5, 461, 0, 0, 2090, 2089, 1, 0, 0, 0, 2090, 2091, 1, 0, 0, 0, 2091, 2303, 1, 0, 0, 0, 2092, 2094, 3, 658, 329, 0, 2093, 2092, 1, 0, 0, 0, 2094, 2097, 1, 0, 0, 0, 2095, 2093, 1, 0, 0, 0, 2095, 2096, 1, 0, 0, 0, 2096, 2098, 1, 0, 0, 0, 2097, 2095, 1, 0, 0, 0, 2098, 2100, 3, 210, 105, 0, 2099, 2101, 5, 461, 0, 0, 2100, 2099, 1, 0, 0, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2303, 1, 0, 0, 0, 2102, 2104, 3, 658, 329, 0, 2103, 2102, 1, 0, 0, 0, 2104, 2107, 1, 0, 0, 0, 2105, 2103, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2108, 1, 0, 0, 0, 2107, 2105, 1, 0, 0, 0, 2108, 2110, 3, 212, 106, 0, 2109, 2111, 5, 461, 0, 0, 2110, 2109, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2303, 1, 0, 0, 0, 2112, 2114, 3, 658, 329, 0, 2113, 2112, 1, 0, 0, 0, 2114, 2117, 1, 0, 0, 0, 2115, 2113, 1, 0, 0, 0, 2115, 2116, 1, 0, 0, 0, 2116, 2118, 1, 0, 0, 0, 2117, 2115, 1, 0, 0, 0, 2118, 2120, 3, 214, 107, 0, 2119, 2121, 5, 461, 0, 0, 2120, 2119, 1, 0, 0, 0, 2120, 2121, 1, 0, 0, 0, 2121, 2303, 1, 0, 0, 0, 2122, 2124, 3, 658, 329, 0, 2123, 2122, 1, 0, 0, 0, 2124, 2127, 1, 0, 0, 0, 2125, 2123, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2128, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2128, 2130, 3, 216, 108, 0, 2129, 2131, 5, 461, 0, 0, 2130, 2129, 1, 0, 0, 0, 2130, 2131, 1, 0, 0, 0, 2131, 2303, 1, 0, 0, 0, 2132, 2134, 3, 658, 329, 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, 2140, 3, 218, 109, 0, 2139, 2141, 5, 461, 0, 0, 2140, 2139, 1, 0, 0, 0, 2140, 2141, 1, 0, 0, 0, 2141, 2303, 1, 0, 0, 0, 2142, 2144, 3, 658, 329, 0, 2143, 2142, 1, 0, 0, 0, 2144, 2147, 1, 0, 0, 0, 2145, 2143, 1, 0, 0, 0, 2145, 2146, 1, 0, 0, 0, 2146, 2148, 1, 0, 0, 0, 2147, 2145, 1, 0, 0, 0, 2148, 2150, 3, 220, 110, 0, 2149, 2151, 5, 461, 0, 0, 2150, 2149, 1, 0, 0, 0, 2150, 2151, 1, 0, 0, 0, 2151, 2303, 1, 0, 0, 0, 2152, 2154, 3, 658, 329, 0, 2153, 2152, 1, 0, 0, 0, 2154, 2157, 1, 0, 0, 0, 2155, 2153, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2158, 1, 0, 0, 0, 2157, 2155, 1, 0, 0, 0, 2158, 2160, 3, 232, 116, 0, 2159, 2161, 5, 461, 0, 0, 2160, 2159, 1, 0, 0, 0, 2160, 2161, 1, 0, 0, 0, 2161, 2303, 1, 0, 0, 0, 2162, 2164, 3, 658, 329, 0, 2163, 2162, 1, 0, 0, 0, 2164, 2167, 1, 0, 0, 0, 2165, 2163, 1, 0, 0, 0, 2165, 2166, 1, 0, 0, 0, 2166, 2168, 1, 0, 0, 0, 2167, 2165, 1, 0, 0, 0, 2168, 2170, 3, 234, 117, 0, 2169, 2171, 5, 461, 0, 0, 2170, 2169, 1, 0, 0, 0, 2170, 2171, 1, 0, 0, 0, 2171, 2303, 1, 0, 0, 0, 2172, 2174, 3, 658, 329, 0, 2173, 2172, 1, 0, 0, 0, 2174, 2177, 1, 0, 0, 0, 2175, 2173, 1, 0, 0, 0, 2175, 2176, 1, 0, 0, 0, 2176, 2178, 1, 0, 0, 0, 2177, 2175, 1, 0, 0, 0, 2178, 2180, 3, 236, 118, 0, 2179, 2181, 5, 461, 0, 0, 2180, 2179, 1, 0, 0, 0, 2180, 2181, 1, 0, 0, 0, 2181, 2303, 1, 0, 0, 0, 2182, 2184, 3, 658, 329, 0, 2183, 2182, 1, 0, 0, 0, 2184, 2187, 1, 0, 0, 0, 2185, 2183, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2188, 1, 0, 0, 0, 2187, 2185, 1, 0, 0, 0, 2188, 2190, 3, 238, 119, 0, 2189, 2191, 5, 461, 0, 0, 2190, 2189, 1, 0, 0, 0, 2190, 2191, 1, 0, 0, 0, 2191, 2303, 1, 0, 0, 0, 2192, 2194, 3, 658, 329, 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, 2200, 3, 244, 122, 0, 2199, 2201, 5, 461, 0, 0, 2200, 2199, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2303, 1, 0, 0, 0, 2202, 2204, 3, 658, 329, 0, 2203, 2202, 1, 0, 0, 0, 2204, 2207, 1, 0, 0, 0, 2205, 2203, 1, 0, 0, 0, 2205, 2206, 1, 0, 0, 0, 2206, 2208, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2210, 3, 250, 125, 0, 2209, 2211, 5, 461, 0, 0, 2210, 2209, 1, 0, 0, 0, 2210, 2211, 1, 0, 0, 0, 2211, 2303, 1, 0, 0, 0, 2212, 2214, 3, 658, 329, 0, 2213, 2212, 1, 0, 0, 0, 2214, 2217, 1, 0, 0, 0, 2215, 2213, 1, 0, 0, 0, 2215, 2216, 1, 0, 0, 0, 2216, 2218, 1, 0, 0, 0, 2217, 2215, 1, 0, 0, 0, 2218, 2220, 3, 252, 126, 0, 2219, 2221, 5, 461, 0, 0, 2220, 2219, 1, 0, 0, 0, 2220, 2221, 1, 0, 0, 0, 2221, 2303, 1, 0, 0, 0, 2222, 2224, 3, 658, 329, 0, 2223, 2222, 1, 0, 0, 0, 2224, 2227, 1, 0, 0, 0, 2225, 2223, 1, 0, 0, 0, 2225, 2226, 1, 0, 0, 0, 2226, 2228, 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2228, 2230, 3, 254, 127, 0, 2229, 2231, 5, 461, 0, 0, 2230, 2229, 1, 0, 0, 0, 2230, 2231, 1, 0, 0, 0, 2231, 2303, 1, 0, 0, 0, 2232, 2234, 3, 658, 329, 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, 256, 128, 0, 2239, 2241, 5, 461, 0, 0, 2240, 2239, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 2303, 1, 0, 0, 0, 2242, 2244, 3, 658, 329, 0, 2243, 2242, 1, 0, 0, 0, 2244, 2247, 1, 0, 0, 0, 2245, 2243, 1, 0, 0, 0, 2245, 2246, 1, 0, 0, 0, 2246, 2248, 1, 0, 0, 0, 2247, 2245, 1, 0, 0, 0, 2248, 2250, 3, 278, 139, 0, 2249, 2251, 5, 461, 0, 0, 2250, 2249, 1, 0, 0, 0, 2250, 2251, 1, 0, 0, 0, 2251, 2303, 1, 0, 0, 0, 2252, 2254, 3, 658, 329, 0, 2253, 2252, 1, 0, 0, 0, 2254, 2257, 1, 0, 0, 0, 2255, 2253, 1, 0, 0, 0, 2255, 2256, 1, 0, 0, 0, 2256, 2258, 1, 0, 0, 0, 2257, 2255, 1, 0, 0, 0, 2258, 2260, 3, 286, 143, 0, 2259, 2261, 5, 461, 0, 0, 2260, 2259, 1, 0, 0, 0, 2260, 2261, 1, 0, 0, 0, 2261, 2303, 1, 0, 0, 0, 2262, 2264, 3, 658, 329, 0, 2263, 2262, 1, 0, 0, 0, 2264, 2267, 1, 0, 0, 0, 2265, 2263, 1, 0, 0, 0, 2265, 2266, 1, 0, 0, 0, 2266, 2268, 1, 0, 0, 0, 2267, 2265, 1, 0, 0, 0, 2268, 2270, 3, 292, 146, 0, 2269, 2271, 5, 461, 0, 0, 2270, 2269, 1, 0, 0, 0, 2270, 2271, 1, 0, 0, 0, 2271, 2303, 1, 0, 0, 0, 2272, 2274, 3, 658, 329, 0, 2273, 2272, 1, 0, 0, 0, 2274, 2277, 1, 0, 0, 0, 2275, 2273, 1, 0, 0, 0, 2275, 2276, 1, 0, 0, 0, 2276, 2278, 1, 0, 0, 0, 2277, 2275, 1, 0, 0, 0, 2278, 2280, 3, 294, 147, 0, 2279, 2281, 5, 461, 0, 0, 2280, 2279, 1, 0, 0, 0, 2280, 2281, 1, 0, 0, 0, 2281, 2303, 1, 0, 0, 0, 2282, 2284, 3, 658, 329, 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, 2290, 3, 258, 129, 0, 2289, 2291, 5, 461, 0, 0, 2290, 2289, 1, 0, 0, 0, 2290, 2291, 1, 0, 0, 0, 2291, 2303, 1, 0, 0, 0, 2292, 2294, 3, 658, 329, 0, 2293, 2292, 1, 0, 0, 0, 2294, 2297, 1, 0, 0, 0, 2295, 2293, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2298, 1, 0, 0, 0, 2297, 2295, 1, 0, 0, 0, 2298, 2300, 3, 260, 130, 0, 2299, 2301, 5, 461, 0, 0, 2300, 2299, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2301, 2303, 1, 0, 0, 0, 2302, 1985, 1, 0, 0, 0, 2302, 1995, 1, 0, 0, 0, 2302, 2005, 1, 0, 0, 0, 2302, 2015, 1, 0, 0, 0, 2302, 2025, 1, 0, 0, 0, 2302, 2035, 1, 0, 0, 0, 2302, 2045, 1, 0, 0, 0, 2302, 2055, 1, 0, 0, 0, 2302, 2065, 1, 0, 0, 0, 2302, 2075, 1, 0, 0, 0, 2302, 2085, 1, 0, 0, 0, 2302, 2095, 1, 0, 0, 0, 2302, 2105, 1, 0, 0, 0, 2302, 2115, 1, 0, 0, 0, 2302, 2125, 1, 0, 0, 0, 2302, 2135, 1, 0, 0, 0, 2302, 2145, 1, 0, 0, 0, 2302, 2155, 1, 0, 0, 0, 2302, 2165, 1, 0, 0, 0, 2302, 2175, 1, 0, 0, 0, 2302, 2185, 1, 0, 0, 0, 2302, 2195, 1, 0, 0, 0, 2302, 2205, 1, 0, 0, 0, 2302, 2215, 1, 0, 0, 0, 2302, 2225, 1, 0, 0, 0, 2302, 2235, 1, 0, 0, 0, 2302, 2245, 1, 0, 0, 0, 2302, 2255, 1, 0, 0, 0, 2302, 2265, 1, 0, 0, 0, 2302, 2275, 1, 0, 0, 0, 2302, 2285, 1, 0, 0, 0, 2302, 2295, 1, 0, 0, 0, 2303, 183, 1, 0, 0, 0, 2304, 2305, 5, 96, 0, 0, 2305, 2306, 5, 481, 0, 0, 2306, 2309, 3, 98, 49, 0, 2307, 2308, 5, 451, 0, 0, 2308, 2310, 3, 608, 304, 0, 2309, 2307, 1, 0, 0, 0, 2309, 2310, 1, 0, 0, 0, 2310, 185, 1, 0, 0, 0, 2311, 2314, 5, 47, 0, 0, 2312, 2315, 5, 481, 0, 0, 2313, 2315, 3, 192, 96, 0, 2314, 2312, 1, 0, 0, 0, 2314, 2313, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2317, 5, 451, 0, 0, 2317, 2318, 3, 608, 304, 0, 2318, 187, 1, 0, 0, 0, 2319, 2320, 5, 481, 0, 0, 2320, 2322, 5, 451, 0, 0, 2321, 2319, 1, 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2323, 1, 0, 0, 0, 2323, 2324, 5, 17, 0, 0, 2324, 2330, 3, 102, 51, 0, 2325, 2327, 5, 464, 0, 0, 2326, 2328, 3, 296, 148, 0, 2327, 2326, 1, 0, 0, 0, 2327, 2328, 1, 0, 0, 0, 2328, 2329, 1, 0, 0, 0, 2329, 2331, 5, 465, 0, 0, 2330, 2325, 1, 0, 0, 0, 2330, 2331, 1, 0, 0, 0, 2331, 2333, 1, 0, 0, 0, 2332, 2334, 3, 204, 102, 0, 2333, 2332, 1, 0, 0, 0, 2333, 2334, 1, 0, 0, 0, 2334, 189, 1, 0, 0, 0, 2335, 2336, 5, 97, 0, 0, 2336, 2342, 5, 481, 0, 0, 2337, 2339, 5, 464, 0, 0, 2338, 2340, 3, 296, 148, 0, 2339, 2338, 1, 0, 0, 0, 2339, 2340, 1, 0, 0, 0, 2340, 2341, 1, 0, 0, 0, 2341, 2343, 5, 465, 0, 0, 2342, 2337, 1, 0, 0, 0, 2342, 2343, 1, 0, 0, 0, 2343, 191, 1, 0, 0, 0, 2344, 2350, 5, 481, 0, 0, 2345, 2348, 7, 11, 0, 0, 2346, 2349, 5, 482, 0, 0, 2347, 2349, 3, 646, 323, 0, 2348, 2346, 1, 0, 0, 0, 2348, 2347, 1, 0, 0, 0, 2349, 2351, 1, 0, 0, 0, 2350, 2345, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, 2352, 2353, 1, 0, 0, 0, 2353, 193, 1, 0, 0, 0, 2354, 2355, 5, 100, 0, 0, 2355, 2358, 5, 481, 0, 0, 2356, 2357, 5, 137, 0, 0, 2357, 2359, 5, 118, 0, 0, 2358, 2356, 1, 0, 0, 0, 2358, 2359, 1, 0, 0, 0, 2359, 2361, 1, 0, 0, 0, 2360, 2362, 5, 383, 0, 0, 2361, 2360, 1, 0, 0, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2365, 3, 204, 102, 0, 2364, 2363, 1, 0, 0, 0, 2364, 2365, 1, 0, 0, 0, 2365, 195, 1, 0, 0, 0, 2366, 2367, 5, 99, 0, 0, 2367, 2369, 5, 481, 0, 0, 2368, 2370, 3, 204, 102, 0, 2369, 2368, 1, 0, 0, 0, 2369, 2370, 1, 0, 0, 0, 2370, 197, 1, 0, 0, 0, 2371, 2372, 5, 101, 0, 0, 2372, 2374, 5, 481, 0, 0, 2373, 2375, 5, 383, 0, 0, 2374, 2373, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 199, 1, 0, 0, 0, 2376, 2377, 5, 98, 0, 0, 2377, 2378, 5, 481, 0, 0, 2378, 2379, 5, 70, 0, 0, 2379, 2385, 3, 202, 101, 0, 2380, 2383, 5, 71, 0, 0, 2381, 2384, 3, 328, 164, 0, 2382, 2384, 3, 608, 304, 0, 2383, 2381, 1, 0, 0, 0, 2383, 2382, 1, 0, 0, 0, 2384, 2386, 1, 0, 0, 0, 2385, 2380, 1, 0, 0, 0, 2385, 2386, 1, 0, 0, 0, 2386, 2396, 1, 0, 0, 0, 2387, 2388, 5, 10, 0, 0, 2388, 2393, 3, 326, 163, 0, 2389, 2390, 5, 462, 0, 0, 2390, 2392, 3, 326, 163, 0, 2391, 2389, 1, 0, 0, 0, 2392, 2395, 1, 0, 0, 0, 2393, 2391, 1, 0, 0, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2397, 1, 0, 0, 0, 2395, 2393, 1, 0, 0, 0, 2396, 2387, 1, 0, 0, 0, 2396, 2397, 1, 0, 0, 0, 2397, 2400, 1, 0, 0, 0, 2398, 2399, 5, 74, 0, 0, 2399, 2401, 3, 608, 304, 0, 2400, 2398, 1, 0, 0, 0, 2400, 2401, 1, 0, 0, 0, 2401, 2404, 1, 0, 0, 0, 2402, 2403, 5, 73, 0, 0, 2403, 2405, 3, 608, 304, 0, 2404, 2402, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 2407, 1, 0, 0, 0, 2406, 2408, 3, 204, 102, 0, 2407, 2406, 1, 0, 0, 0, 2407, 2408, 1, 0, 0, 0, 2408, 201, 1, 0, 0, 0, 2409, 2417, 3, 646, 323, 0, 2410, 2411, 5, 464, 0, 0, 2411, 2412, 3, 522, 261, 0, 2412, 2413, 5, 465, 0, 0, 2413, 2417, 1, 0, 0, 0, 2414, 2415, 5, 343, 0, 0, 2415, 2417, 5, 478, 0, 0, 2416, 2409, 1, 0, 0, 0, 2416, 2410, 1, 0, 0, 0, 2416, 2414, 1, 0, 0, 0, 2417, 203, 1, 0, 0, 0, 2418, 2419, 5, 92, 0, 0, 2419, 2420, 5, 297, 0, 0, 2420, 2439, 5, 107, 0, 0, 2421, 2422, 5, 92, 0, 0, 2422, 2423, 5, 297, 0, 0, 2423, 2439, 5, 101, 0, 0, 2424, 2425, 5, 92, 0, 0, 2425, 2426, 5, 297, 0, 0, 2426, 2427, 5, 466, 0, 0, 2427, 2428, 3, 180, 90, 0, 2428, 2429, 5, 467, 0, 0, 2429, 2439, 1, 0, 0, 0, 2430, 2431, 5, 92, 0, 0, 2431, 2432, 5, 297, 0, 0, 2432, 2433, 5, 419, 0, 0, 2433, 2434, 5, 101, 0, 0, 2434, 2435, 5, 466, 0, 0, 2435, 2436, 3, 180, 90, 0, 2436, 2437, 5, 467, 0, 0, 2437, 2439, 1, 0, 0, 0, 2438, 2418, 1, 0, 0, 0, 2438, 2421, 1, 0, 0, 0, 2438, 2424, 1, 0, 0, 0, 2438, 2430, 1, 0, 0, 0, 2439, 205, 1, 0, 0, 0, 2440, 2441, 5, 104, 0, 0, 2441, 2442, 3, 608, 304, 0, 2442, 2443, 5, 80, 0, 0, 2443, 2451, 3, 180, 90, 0, 2444, 2445, 5, 105, 0, 0, 2445, 2446, 3, 608, 304, 0, 2446, 2447, 5, 80, 0, 0, 2447, 2448, 3, 180, 90, 0, 2448, 2450, 1, 0, 0, 0, 2449, 2444, 1, 0, 0, 0, 2450, 2453, 1, 0, 0, 0, 2451, 2449, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, 0, 2452, 2456, 1, 0, 0, 0, 2453, 2451, 1, 0, 0, 0, 2454, 2455, 5, 81, 0, 0, 2455, 2457, 3, 180, 90, 0, 2456, 2454, 1, 0, 0, 0, 2456, 2457, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2459, 5, 82, 0, 0, 2459, 2460, 5, 104, 0, 0, 2460, 207, 1, 0, 0, 0, 2461, 2462, 5, 102, 0, 0, 2462, 2463, 5, 481, 0, 0, 2463, 2466, 5, 284, 0, 0, 2464, 2467, 5, 481, 0, 0, 2465, 2467, 3, 192, 96, 0, 2466, 2464, 1, 0, 0, 0, 2466, 2465, 1, 0, 0, 0, 2467, 2468, 1, 0, 0, 0, 2468, 2469, 5, 95, 0, 0, 2469, 2470, 3, 180, 90, 0, 2470, 2471, 5, 82, 0, 0, 2471, 2472, 5, 102, 0, 0, 2472, 209, 1, 0, 0, 0, 2473, 2474, 5, 103, 0, 0, 2474, 2476, 3, 608, 304, 0, 2475, 2477, 5, 95, 0, 0, 2476, 2475, 1, 0, 0, 0, 2476, 2477, 1, 0, 0, 0, 2477, 2478, 1, 0, 0, 0, 2478, 2479, 3, 180, 90, 0, 2479, 2481, 5, 82, 0, 0, 2480, 2482, 5, 103, 0, 0, 2481, 2480, 1, 0, 0, 0, 2481, 2482, 1, 0, 0, 0, 2482, 211, 1, 0, 0, 0, 2483, 2484, 5, 107, 0, 0, 2484, 213, 1, 0, 0, 0, 2485, 2486, 5, 108, 0, 0, 2486, 215, 1, 0, 0, 0, 2487, 2489, 5, 109, 0, 0, 2488, 2490, 3, 608, 304, 0, 2489, 2488, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 217, 1, 0, 0, 0, 2491, 2492, 5, 298, 0, 0, 2492, 2493, 5, 297, 0, 0, 2493, 219, 1, 0, 0, 0, 2494, 2496, 5, 111, 0, 0, 2495, 2497, 3, 222, 111, 0, 2496, 2495, 1, 0, 0, 0, 2496, 2497, 1, 0, 0, 0, 2497, 2500, 1, 0, 0, 0, 2498, 2499, 5, 117, 0, 0, 2499, 2501, 5, 478, 0, 0, 2500, 2498, 1, 0, 0, 0, 2500, 2501, 1, 0, 0, 0, 2501, 2502, 1, 0, 0, 0, 2502, 2504, 3, 608, 304, 0, 2503, 2505, 3, 228, 114, 0, 2504, 2503, 1, 0, 0, 0, 2504, 2505, 1, 0, 0, 0, 2505, 221, 1, 0, 0, 0, 2506, 2507, 7, 12, 0, 0, 2507, 223, 1, 0, 0, 0, 2508, 2509, 5, 137, 0, 0, 2509, 2510, 5, 464, 0, 0, 2510, 2515, 3, 226, 113, 0, 2511, 2512, 5, 462, 0, 0, 2512, 2514, 3, 226, 113, 0, 2513, 2511, 1, 0, 0, 0, 2514, 2517, 1, 0, 0, 0, 2515, 2513, 1, 0, 0, 0, 2515, 2516, 1, 0, 0, 0, 2516, 2518, 1, 0, 0, 0, 2517, 2515, 1, 0, 0, 0, 2518, 2519, 5, 465, 0, 0, 2519, 2523, 1, 0, 0, 0, 2520, 2521, 5, 359, 0, 0, 2521, 2523, 3, 652, 326, 0, 2522, 2508, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2523, 225, 1, 0, 0, 0, 2524, 2525, 5, 466, 0, 0, 2525, 2526, 5, 480, 0, 0, 2526, 2527, 5, 467, 0, 0, 2527, 2528, 5, 451, 0, 0, 2528, 2529, 3, 608, 304, 0, 2529, 227, 1, 0, 0, 0, 2530, 2531, 3, 224, 112, 0, 2531, 229, 1, 0, 0, 0, 2532, 2533, 3, 226, 113, 0, 2533, 231, 1, 0, 0, 0, 2534, 2535, 5, 481, 0, 0, 2535, 2537, 5, 451, 0, 0, 2536, 2534, 1, 0, 0, 0, 2536, 2537, 1, 0, 0, 0, 2537, 2538, 1, 0, 0, 0, 2538, 2539, 5, 112, 0, 0, 2539, 2540, 5, 30, 0, 0, 2540, 2541, 3, 646, 323, 0, 2541, 2543, 5, 464, 0, 0, 2542, 2544, 3, 240, 120, 0, 2543, 2542, 1, 0, 0, 0, 2543, 2544, 1, 0, 0, 0, 2544, 2545, 1, 0, 0, 0, 2545, 2547, 5, 465, 0, 0, 2546, 2548, 3, 204, 102, 0, 2547, 2546, 1, 0, 0, 0, 2547, 2548, 1, 0, 0, 0, 2548, 233, 1, 0, 0, 0, 2549, 2550, 5, 481, 0, 0, 2550, 2552, 5, 451, 0, 0, 2551, 2549, 1, 0, 0, 0, 2551, 2552, 1, 0, 0, 0, 2552, 2553, 1, 0, 0, 0, 2553, 2554, 5, 112, 0, 0, 2554, 2555, 5, 113, 0, 0, 2555, 2556, 5, 114, 0, 0, 2556, 2557, 3, 646, 323, 0, 2557, 2559, 5, 464, 0, 0, 2558, 2560, 3, 240, 120, 0, 2559, 2558, 1, 0, 0, 0, 2559, 2560, 1, 0, 0, 0, 2560, 2561, 1, 0, 0, 0, 2561, 2563, 5, 465, 0, 0, 2562, 2564, 3, 204, 102, 0, 2563, 2562, 1, 0, 0, 0, 2563, 2564, 1, 0, 0, 0, 2564, 235, 1, 0, 0, 0, 2565, 2566, 5, 481, 0, 0, 2566, 2568, 5, 451, 0, 0, 2567, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2569, 1, 0, 0, 0, 2569, 2570, 5, 386, 0, 0, 2570, 2571, 5, 343, 0, 0, 2571, 2572, 5, 344, 0, 0, 2572, 2579, 3, 646, 323, 0, 2573, 2577, 5, 164, 0, 0, 2574, 2578, 5, 478, 0, 0, 2575, 2578, 5, 479, 0, 0, 2576, 2578, 3, 608, 304, 0, 2577, 2574, 1, 0, 0, 0, 2577, 2575, 1, 0, 0, 0, 2577, 2576, 1, 0, 0, 0, 2578, 2580, 1, 0, 0, 0, 2579, 2573, 1, 0, 0, 0, 2579, 2580, 1, 0, 0, 0, 2580, 2586, 1, 0, 0, 0, 2581, 2583, 5, 464, 0, 0, 2582, 2584, 3, 240, 120, 0, 2583, 2582, 1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, 2585, 1, 0, 0, 0, 2585, 2587, 5, 465, 0, 0, 2586, 2581, 1, 0, 0, 0, 2586, 2587, 1, 0, 0, 0, 2587, 2594, 1, 0, 0, 0, 2588, 2589, 5, 342, 0, 0, 2589, 2591, 5, 464, 0, 0, 2590, 2592, 3, 240, 120, 0, 2591, 2590, 1, 0, 0, 0, 2591, 2592, 1, 0, 0, 0, 2592, 2593, 1, 0, 0, 0, 2593, 2595, 5, 465, 0, 0, 2594, 2588, 1, 0, 0, 0, 2594, 2595, 1, 0, 0, 0, 2595, 2597, 1, 0, 0, 0, 2596, 2598, 3, 204, 102, 0, 2597, 2596, 1, 0, 0, 0, 2597, 2598, 1, 0, 0, 0, 2598, 237, 1, 0, 0, 0, 2599, 2600, 5, 481, 0, 0, 2600, 2602, 5, 451, 0, 0, 2601, 2599, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, 2604, 5, 112, 0, 0, 2604, 2605, 5, 26, 0, 0, 2605, 2606, 5, 114, 0, 0, 2606, 2607, 3, 646, 323, 0, 2607, 2609, 5, 464, 0, 0, 2608, 2610, 3, 240, 120, 0, 2609, 2608, 1, 0, 0, 0, 2609, 2610, 1, 0, 0, 0, 2610, 2611, 1, 0, 0, 0, 2611, 2613, 5, 465, 0, 0, 2612, 2614, 3, 204, 102, 0, 2613, 2612, 1, 0, 0, 0, 2613, 2614, 1, 0, 0, 0, 2614, 239, 1, 0, 0, 0, 2615, 2620, 3, 242, 121, 0, 2616, 2617, 5, 462, 0, 0, 2617, 2619, 3, 242, 121, 0, 2618, 2616, 1, 0, 0, 0, 2619, 2622, 1, 0, 0, 0, 2620, 2618, 1, 0, 0, 0, 2620, 2621, 1, 0, 0, 0, 2621, 241, 1, 0, 0, 0, 2622, 2620, 1, 0, 0, 0, 2623, 2626, 5, 481, 0, 0, 2624, 2626, 3, 172, 86, 0, 2625, 2623, 1, 0, 0, 0, 2625, 2624, 1, 0, 0, 0, 2626, 2627, 1, 0, 0, 0, 2627, 2628, 5, 451, 0, 0, 2628, 2629, 3, 608, 304, 0, 2629, 243, 1, 0, 0, 0, 2630, 2631, 5, 64, 0, 0, 2631, 2632, 5, 33, 0, 0, 2632, 2638, 3, 646, 323, 0, 2633, 2635, 5, 464, 0, 0, 2634, 2636, 3, 246, 123, 0, 2635, 2634, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, 2637, 1, 0, 0, 0, 2637, 2639, 5, 465, 0, 0, 2638, 2633, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2642, 1, 0, 0, 0, 2640, 2641, 5, 413, 0, 0, 2641, 2643, 5, 481, 0, 0, 2642, 2640, 1, 0, 0, 0, 2642, 2643, 1, 0, 0, 0, 2643, 2646, 1, 0, 0, 0, 2644, 2645, 5, 137, 0, 0, 2645, 2647, 3, 296, 148, 0, 2646, 2644, 1, 0, 0, 0, 2646, 2647, 1, 0, 0, 0, 2647, 245, 1, 0, 0, 0, 2648, 2653, 3, 248, 124, 0, 2649, 2650, 5, 462, 0, 0, 2650, 2652, 3, 248, 124, 0, 2651, 2649, 1, 0, 0, 0, 2652, 2655, 1, 0, 0, 0, 2653, 2651, 1, 0, 0, 0, 2653, 2654, 1, 0, 0, 0, 2654, 247, 1, 0, 0, 0, 2655, 2653, 1, 0, 0, 0, 2656, 2657, 5, 481, 0, 0, 2657, 2660, 5, 451, 0, 0, 2658, 2661, 5, 481, 0, 0, 2659, 2661, 3, 608, 304, 0, 2660, 2658, 1, 0, 0, 0, 2660, 2659, 1, 0, 0, 0, 2661, 2667, 1, 0, 0, 0, 2662, 2663, 3, 648, 324, 0, 2663, 2664, 5, 470, 0, 0, 2664, 2665, 3, 608, 304, 0, 2665, 2667, 1, 0, 0, 0, 2666, 2656, 1, 0, 0, 0, 2666, 2662, 1, 0, 0, 0, 2667, 249, 1, 0, 0, 0, 2668, 2669, 5, 116, 0, 0, 2669, 2670, 5, 33, 0, 0, 2670, 251, 1, 0, 0, 0, 2671, 2672, 5, 64, 0, 0, 2672, 2673, 5, 364, 0, 0, 2673, 2674, 5, 33, 0, 0, 2674, 253, 1, 0, 0, 0, 2675, 2676, 5, 64, 0, 0, 2676, 2677, 5, 392, 0, 0, 2677, 2680, 3, 608, 304, 0, 2678, 2679, 5, 404, 0, 0, 2679, 2681, 3, 648, 324, 0, 2680, 2678, 1, 0, 0, 0, 2680, 2681, 1, 0, 0, 0, 2681, 2687, 1, 0, 0, 0, 2682, 2683, 5, 140, 0, 0, 2683, 2684, 5, 468, 0, 0, 2684, 2685, 3, 644, 322, 0, 2685, 2686, 5, 469, 0, 0, 2686, 2688, 1, 0, 0, 0, 2687, 2682, 1, 0, 0, 0, 2687, 2688, 1, 0, 0, 0, 2688, 255, 1, 0, 0, 0, 2689, 2690, 5, 110, 0, 0, 2690, 2691, 3, 608, 304, 0, 2691, 257, 1, 0, 0, 0, 2692, 2693, 5, 293, 0, 0, 2693, 2694, 5, 294, 0, 0, 2694, 2695, 3, 192, 96, 0, 2695, 2696, 5, 392, 0, 0, 2696, 2702, 3, 608, 304, 0, 2697, 2698, 5, 140, 0, 0, 2698, 2699, 5, 468, 0, 0, 2699, 2700, 3, 644, 322, 0, 2700, 2701, 5, 469, 0, 0, 2701, 2703, 1, 0, 0, 0, 2702, 2697, 1, 0, 0, 0, 2702, 2703, 1, 0, 0, 0, 2703, 259, 1, 0, 0, 0, 2704, 2705, 5, 481, 0, 0, 2705, 2707, 5, 451, 0, 0, 2706, 2704, 1, 0, 0, 0, 2706, 2707, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 2709, 5, 305, 0, 0, 2709, 2710, 5, 112, 0, 0, 2710, 2711, 3, 262, 131, 0, 2711, 2713, 3, 264, 132, 0, 2712, 2714, 3, 266, 133, 0, 2713, 2712, 1, 0, 0, 0, 2713, 2714, 1, 0, 0, 0, 2714, 2718, 1, 0, 0, 0, 2715, 2717, 3, 268, 134, 0, 2716, 2715, 1, 0, 0, 0, 2717, 2720, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2718, 2719, 1, 0, 0, 0, 2719, 2722, 1, 0, 0, 0, 2720, 2718, 1, 0, 0, 0, 2721, 2723, 3, 270, 135, 0, 2722, 2721, 1, 0, 0, 0, 2722, 2723, 1, 0, 0, 0, 2723, 2725, 1, 0, 0, 0, 2724, 2726, 3, 272, 136, 0, 2725, 2724, 1, 0, 0, 0, 2725, 2726, 1, 0, 0, 0, 2726, 2728, 1, 0, 0, 0, 2727, 2729, 3, 274, 137, 0, 2728, 2727, 1, 0, 0, 0, 2728, 2729, 1, 0, 0, 0, 2729, 2730, 1, 0, 0, 0, 2730, 2732, 3, 276, 138, 0, 2731, 2733, 3, 204, 102, 0, 2732, 2731, 1, 0, 0, 0, 2732, 2733, 1, 0, 0, 0, 2733, 261, 1, 0, 0, 0, 2734, 2735, 7, 13, 0, 0, 2735, 263, 1, 0, 0, 0, 2736, 2739, 5, 478, 0, 0, 2737, 2739, 3, 608, 304, 0, 2738, 2736, 1, 0, 0, 0, 2738, 2737, 1, 0, 0, 0, 2739, 265, 1, 0, 0, 0, 2740, 2741, 3, 224, 112, 0, 2741, 267, 1, 0, 0, 0, 2742, 2743, 5, 193, 0, 0, 2743, 2744, 7, 14, 0, 0, 2744, 2745, 5, 451, 0, 0, 2745, 2746, 3, 608, 304, 0, 2746, 269, 1, 0, 0, 0, 2747, 2748, 5, 310, 0, 0, 2748, 2749, 5, 312, 0, 0, 2749, 2750, 3, 608, 304, 0, 2750, 2751, 5, 341, 0, 0, 2751, 2752, 3, 608, 304, 0, 2752, 271, 1, 0, 0, 0, 2753, 2754, 5, 319, 0, 0, 2754, 2756, 5, 478, 0, 0, 2755, 2757, 3, 224, 112, 0, 2756, 2755, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2770, 1, 0, 0, 0, 2758, 2759, 5, 319, 0, 0, 2759, 2761, 3, 608, 304, 0, 2760, 2762, 3, 224, 112, 0, 2761, 2760, 1, 0, 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2770, 1, 0, 0, 0, 2763, 2764, 5, 319, 0, 0, 2764, 2765, 5, 346, 0, 0, 2765, 2766, 3, 646, 323, 0, 2766, 2767, 5, 70, 0, 0, 2767, 2768, 5, 481, 0, 0, 2768, 2770, 1, 0, 0, 0, 2769, 2753, 1, 0, 0, 0, 2769, 2758, 1, 0, 0, 0, 2769, 2763, 1, 0, 0, 0, 2770, 273, 1, 0, 0, 0, 2771, 2772, 5, 318, 0, 0, 2772, 2773, 3, 608, 304, 0, 2773, 275, 1, 0, 0, 0, 2774, 2775, 5, 76, 0, 0, 2775, 2789, 5, 257, 0, 0, 2776, 2777, 5, 76, 0, 0, 2777, 2789, 5, 320, 0, 0, 2778, 2779, 5, 76, 0, 0, 2779, 2780, 5, 346, 0, 0, 2780, 2781, 3, 646, 323, 0, 2781, 2782, 5, 75, 0, 0, 2782, 2783, 3, 646, 323, 0, 2783, 2789, 1, 0, 0, 0, 2784, 2785, 5, 76, 0, 0, 2785, 2789, 5, 408, 0, 0, 2786, 2787, 5, 76, 0, 0, 2787, 2789, 5, 313, 0, 0, 2788, 2774, 1, 0, 0, 0, 2788, 2776, 1, 0, 0, 0, 2788, 2778, 1, 0, 0, 0, 2788, 2784, 1, 0, 0, 0, 2788, 2786, 1, 0, 0, 0, 2789, 277, 1, 0, 0, 0, 2790, 2791, 5, 481, 0, 0, 2791, 2792, 5, 451, 0, 0, 2792, 2793, 3, 280, 140, 0, 2793, 279, 1, 0, 0, 0, 2794, 2795, 5, 119, 0, 0, 2795, 2796, 5, 464, 0, 0, 2796, 2797, 5, 481, 0, 0, 2797, 2854, 5, 465, 0, 0, 2798, 2799, 5, 120, 0, 0, 2799, 2800, 5, 464, 0, 0, 2800, 2801, 5, 481, 0, 0, 2801, 2854, 5, 465, 0, 0, 2802, 2803, 5, 121, 0, 0, 2803, 2804, 5, 464, 0, 0, 2804, 2805, 5, 481, 0, 0, 2805, 2806, 5, 462, 0, 0, 2806, 2807, 3, 608, 304, 0, 2807, 2808, 5, 465, 0, 0, 2808, 2854, 1, 0, 0, 0, 2809, 2810, 5, 183, 0, 0, 2810, 2811, 5, 464, 0, 0, 2811, 2812, 5, 481, 0, 0, 2812, 2813, 5, 462, 0, 0, 2813, 2814, 3, 608, 304, 0, 2814, 2815, 5, 465, 0, 0, 2815, 2854, 1, 0, 0, 0, 2816, 2817, 5, 122, 0, 0, 2817, 2818, 5, 464, 0, 0, 2818, 2819, 5, 481, 0, 0, 2819, 2820, 5, 462, 0, 0, 2820, 2821, 3, 282, 141, 0, 2821, 2822, 5, 465, 0, 0, 2822, 2854, 1, 0, 0, 0, 2823, 2824, 5, 123, 0, 0, 2824, 2825, 5, 464, 0, 0, 2825, 2826, 5, 481, 0, 0, 2826, 2827, 5, 462, 0, 0, 2827, 2828, 5, 481, 0, 0, 2828, 2854, 5, 465, 0, 0, 2829, 2830, 5, 124, 0, 0, 2830, 2831, 5, 464, 0, 0, 2831, 2832, 5, 481, 0, 0, 2832, 2833, 5, 462, 0, 0, 2833, 2834, 5, 481, 0, 0, 2834, 2854, 5, 465, 0, 0, 2835, 2836, 5, 125, 0, 0, 2836, 2837, 5, 464, 0, 0, 2837, 2838, 5, 481, 0, 0, 2838, 2839, 5, 462, 0, 0, 2839, 2840, 5, 481, 0, 0, 2840, 2854, 5, 465, 0, 0, 2841, 2842, 5, 126, 0, 0, 2842, 2843, 5, 464, 0, 0, 2843, 2844, 5, 481, 0, 0, 2844, 2845, 5, 462, 0, 0, 2845, 2846, 5, 481, 0, 0, 2846, 2854, 5, 465, 0, 0, 2847, 2848, 5, 132, 0, 0, 2848, 2849, 5, 464, 0, 0, 2849, 2850, 5, 481, 0, 0, 2850, 2851, 5, 462, 0, 0, 2851, 2852, 5, 481, 0, 0, 2852, 2854, 5, 465, 0, 0, 2853, 2794, 1, 0, 0, 0, 2853, 2798, 1, 0, 0, 0, 2853, 2802, 1, 0, 0, 0, 2853, 2809, 1, 0, 0, 0, 2853, 2816, 1, 0, 0, 0, 2853, 2823, 1, 0, 0, 0, 2853, 2829, 1, 0, 0, 0, 2853, 2835, 1, 0, 0, 0, 2853, 2841, 1, 0, 0, 0, 2853, 2847, 1, 0, 0, 0, 2854, 281, 1, 0, 0, 0, 2855, 2860, 3, 284, 142, 0, 2856, 2857, 5, 462, 0, 0, 2857, 2859, 3, 284, 142, 0, 2858, 2856, 1, 0, 0, 0, 2859, 2862, 1, 0, 0, 0, 2860, 2858, 1, 0, 0, 0, 2860, 2861, 1, 0, 0, 0, 2861, 283, 1, 0, 0, 0, 2862, 2860, 1, 0, 0, 0, 2863, 2865, 5, 482, 0, 0, 2864, 2866, 7, 6, 0, 0, 2865, 2864, 1, 0, 0, 0, 2865, 2866, 1, 0, 0, 0, 2866, 285, 1, 0, 0, 0, 2867, 2868, 5, 481, 0, 0, 2868, 2869, 5, 451, 0, 0, 2869, 2870, 3, 288, 144, 0, 2870, 287, 1, 0, 0, 0, 2871, 2872, 5, 271, 0, 0, 2872, 2873, 5, 464, 0, 0, 2873, 2874, 5, 481, 0, 0, 2874, 2896, 5, 465, 0, 0, 2875, 2876, 5, 272, 0, 0, 2876, 2877, 5, 464, 0, 0, 2877, 2878, 3, 192, 96, 0, 2878, 2879, 5, 465, 0, 0, 2879, 2896, 1, 0, 0, 0, 2880, 2881, 5, 127, 0, 0, 2881, 2882, 5, 464, 0, 0, 2882, 2883, 3, 192, 96, 0, 2883, 2884, 5, 465, 0, 0, 2884, 2896, 1, 0, 0, 0, 2885, 2886, 5, 128, 0, 0, 2886, 2887, 5, 464, 0, 0, 2887, 2888, 3, 192, 96, 0, 2888, 2889, 5, 465, 0, 0, 2889, 2896, 1, 0, 0, 0, 2890, 2891, 5, 129, 0, 0, 2891, 2892, 5, 464, 0, 0, 2892, 2893, 3, 192, 96, 0, 2893, 2894, 5, 465, 0, 0, 2894, 2896, 1, 0, 0, 0, 2895, 2871, 1, 0, 0, 0, 2895, 2875, 1, 0, 0, 0, 2895, 2880, 1, 0, 0, 0, 2895, 2885, 1, 0, 0, 0, 2895, 2890, 1, 0, 0, 0, 2896, 289, 1, 0, 0, 0, 2897, 2898, 5, 481, 0, 0, 2898, 2899, 5, 451, 0, 0, 2899, 2900, 5, 17, 0, 0, 2900, 2901, 5, 13, 0, 0, 2901, 2902, 3, 646, 323, 0, 2902, 291, 1, 0, 0, 0, 2903, 2904, 5, 46, 0, 0, 2904, 2905, 5, 481, 0, 0, 2905, 2906, 5, 410, 0, 0, 2906, 2907, 5, 481, 0, 0, 2907, 293, 1, 0, 0, 0, 2908, 2909, 5, 131, 0, 0, 2909, 2910, 5, 481, 0, 0, 2910, 2911, 5, 70, 0, 0, 2911, 2912, 5, 481, 0, 0, 2912, 295, 1, 0, 0, 0, 2913, 2918, 3, 298, 149, 0, 2914, 2915, 5, 462, 0, 0, 2915, 2917, 3, 298, 149, 0, 2916, 2914, 1, 0, 0, 0, 2917, 2920, 1, 0, 0, 0, 2918, 2916, 1, 0, 0, 0, 2918, 2919, 1, 0, 0, 0, 2919, 297, 1, 0, 0, 0, 2920, 2918, 1, 0, 0, 0, 2921, 2922, 3, 300, 150, 0, 2922, 2923, 5, 451, 0, 0, 2923, 2924, 3, 608, 304, 0, 2924, 299, 1, 0, 0, 0, 2925, 2930, 3, 646, 323, 0, 2926, 2930, 5, 482, 0, 0, 2927, 2930, 5, 484, 0, 0, 2928, 2930, 3, 668, 334, 0, 2929, 2925, 1, 0, 0, 0, 2929, 2926, 1, 0, 0, 0, 2929, 2927, 1, 0, 0, 0, 2929, 2928, 1, 0, 0, 0, 2930, 301, 1, 0, 0, 0, 2931, 2936, 3, 304, 152, 0, 2932, 2933, 5, 462, 0, 0, 2933, 2935, 3, 304, 152, 0, 2934, 2932, 1, 0, 0, 0, 2935, 2938, 1, 0, 0, 0, 2936, 2934, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 303, 1, 0, 0, 0, 2938, 2936, 1, 0, 0, 0, 2939, 2940, 5, 482, 0, 0, 2940, 2941, 5, 451, 0, 0, 2941, 2942, 3, 608, 304, 0, 2942, 305, 1, 0, 0, 0, 2943, 2944, 5, 33, 0, 0, 2944, 2945, 3, 646, 323, 0, 2945, 2946, 3, 356, 178, 0, 2946, 2947, 5, 466, 0, 0, 2947, 2948, 3, 364, 182, 0, 2948, 2949, 5, 467, 0, 0, 2949, 307, 1, 0, 0, 0, 2950, 2951, 5, 34, 0, 0, 2951, 2953, 3, 646, 323, 0, 2952, 2954, 3, 360, 180, 0, 2953, 2952, 1, 0, 0, 0, 2953, 2954, 1, 0, 0, 0, 2954, 2956, 1, 0, 0, 0, 2955, 2957, 3, 310, 155, 0, 2956, 2955, 1, 0, 0, 0, 2956, 2957, 1, 0, 0, 0, 2957, 2958, 1, 0, 0, 0, 2958, 2959, 5, 466, 0, 0, 2959, 2960, 3, 364, 182, 0, 2960, 2961, 5, 467, 0, 0, 2961, 309, 1, 0, 0, 0, 2962, 2964, 3, 312, 156, 0, 2963, 2962, 1, 0, 0, 0, 2964, 2965, 1, 0, 0, 0, 2965, 2963, 1, 0, 0, 0, 2965, 2966, 1, 0, 0, 0, 2966, 311, 1, 0, 0, 0, 2967, 2968, 5, 215, 0, 0, 2968, 2969, 5, 478, 0, 0, 2969, 313, 1, 0, 0, 0, 2970, 2975, 3, 316, 158, 0, 2971, 2972, 5, 462, 0, 0, 2972, 2974, 3, 316, 158, 0, 2973, 2971, 1, 0, 0, 0, 2974, 2977, 1, 0, 0, 0, 2975, 2973, 1, 0, 0, 0, 2975, 2976, 1, 0, 0, 0, 2976, 315, 1, 0, 0, 0, 2977, 2975, 1, 0, 0, 0, 2978, 2979, 7, 15, 0, 0, 2979, 2980, 5, 470, 0, 0, 2980, 2981, 3, 98, 49, 0, 2981, 317, 1, 0, 0, 0, 2982, 2987, 3, 320, 160, 0, 2983, 2984, 5, 462, 0, 0, 2984, 2986, 3, 320, 160, 0, 2985, 2983, 1, 0, 0, 0, 2986, 2989, 1, 0, 0, 0, 2987, 2985, 1, 0, 0, 0, 2987, 2988, 1, 0, 0, 0, 2988, 319, 1, 0, 0, 0, 2989, 2987, 1, 0, 0, 0, 2990, 2991, 7, 15, 0, 0, 2991, 2992, 5, 470, 0, 0, 2992, 2993, 3, 98, 49, 0, 2993, 321, 1, 0, 0, 0, 2994, 2999, 3, 324, 162, 0, 2995, 2996, 5, 462, 0, 0, 2996, 2998, 3, 324, 162, 0, 2997, 2995, 1, 0, 0, 0, 2998, 3001, 1, 0, 0, 0, 2999, 2997, 1, 0, 0, 0, 2999, 3000, 1, 0, 0, 0, 3000, 323, 1, 0, 0, 0, 3001, 2999, 1, 0, 0, 0, 3002, 3003, 5, 481, 0, 0, 3003, 3004, 5, 470, 0, 0, 3004, 3005, 3, 98, 49, 0, 3005, 3006, 5, 451, 0, 0, 3006, 3007, 5, 478, 0, 0, 3007, 325, 1, 0, 0, 0, 3008, 3011, 3, 646, 323, 0, 3009, 3011, 5, 482, 0, 0, 3010, 3008, 1, 0, 0, 0, 3010, 3009, 1, 0, 0, 0, 3011, 3013, 1, 0, 0, 0, 3012, 3014, 7, 6, 0, 0, 3013, 3012, 1, 0, 0, 0, 3013, 3014, 1, 0, 0, 0, 3014, 327, 1, 0, 0, 0, 3015, 3016, 5, 468, 0, 0, 3016, 3017, 3, 332, 166, 0, 3017, 3018, 5, 469, 0, 0, 3018, 329, 1, 0, 0, 0, 3019, 3020, 7, 16, 0, 0, 3020, 331, 1, 0, 0, 0, 3021, 3026, 3, 334, 167, 0, 3022, 3023, 5, 281, 0, 0, 3023, 3025, 3, 334, 167, 0, 3024, 3022, 1, 0, 0, 0, 3025, 3028, 1, 0, 0, 0, 3026, 3024, 1, 0, 0, 0, 3026, 3027, 1, 0, 0, 0, 3027, 333, 1, 0, 0, 0, 3028, 3026, 1, 0, 0, 0, 3029, 3034, 3, 336, 168, 0, 3030, 3031, 5, 280, 0, 0, 3031, 3033, 3, 336, 168, 0, 3032, 3030, 1, 0, 0, 0, 3033, 3036, 1, 0, 0, 0, 3034, 3032, 1, 0, 0, 0, 3034, 3035, 1, 0, 0, 0, 3035, 335, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3037, 3038, 5, 282, 0, 0, 3038, 3041, 3, 336, 168, 0, 3039, 3041, 3, 338, 169, 0, 3040, 3037, 1, 0, 0, 0, 3040, 3039, 1, 0, 0, 0, 3041, 337, 1, 0, 0, 0, 3042, 3046, 3, 340, 170, 0, 3043, 3044, 3, 618, 309, 0, 3044, 3045, 3, 340, 170, 0, 3045, 3047, 1, 0, 0, 0, 3046, 3043, 1, 0, 0, 0, 3046, 3047, 1, 0, 0, 0, 3047, 339, 1, 0, 0, 0, 3048, 3055, 3, 352, 176, 0, 3049, 3055, 3, 342, 171, 0, 3050, 3051, 5, 464, 0, 0, 3051, 3052, 3, 332, 166, 0, 3052, 3053, 5, 465, 0, 0, 3053, 3055, 1, 0, 0, 0, 3054, 3048, 1, 0, 0, 0, 3054, 3049, 1, 0, 0, 0, 3054, 3050, 1, 0, 0, 0, 3055, 341, 1, 0, 0, 0, 3056, 3061, 3, 344, 172, 0, 3057, 3058, 5, 457, 0, 0, 3058, 3060, 3, 344, 172, 0, 3059, 3057, 1, 0, 0, 0, 3060, 3063, 1, 0, 0, 0, 3061, 3059, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 343, 1, 0, 0, 0, 3063, 3061, 1, 0, 0, 0, 3064, 3069, 3, 346, 173, 0, 3065, 3066, 5, 468, 0, 0, 3066, 3067, 3, 332, 166, 0, 3067, 3068, 5, 469, 0, 0, 3068, 3070, 1, 0, 0, 0, 3069, 3065, 1, 0, 0, 0, 3069, 3070, 1, 0, 0, 0, 3070, 345, 1, 0, 0, 0, 3071, 3077, 3, 348, 174, 0, 3072, 3077, 5, 481, 0, 0, 3073, 3077, 5, 478, 0, 0, 3074, 3077, 5, 480, 0, 0, 3075, 3077, 5, 477, 0, 0, 3076, 3071, 1, 0, 0, 0, 3076, 3072, 1, 0, 0, 0, 3076, 3073, 1, 0, 0, 0, 3076, 3074, 1, 0, 0, 0, 3076, 3075, 1, 0, 0, 0, 3077, 347, 1, 0, 0, 0, 3078, 3083, 3, 350, 175, 0, 3079, 3080, 5, 463, 0, 0, 3080, 3082, 3, 350, 175, 0, 3081, 3079, 1, 0, 0, 0, 3082, 3085, 1, 0, 0, 0, 3083, 3081, 1, 0, 0, 0, 3083, 3084, 1, 0, 0, 0, 3084, 349, 1, 0, 0, 0, 3085, 3083, 1, 0, 0, 0, 3086, 3087, 8, 17, 0, 0, 3087, 351, 1, 0, 0, 0, 3088, 3089, 3, 354, 177, 0, 3089, 3098, 5, 464, 0, 0, 3090, 3095, 3, 332, 166, 0, 3091, 3092, 5, 462, 0, 0, 3092, 3094, 3, 332, 166, 0, 3093, 3091, 1, 0, 0, 0, 3094, 3097, 1, 0, 0, 0, 3095, 3093, 1, 0, 0, 0, 3095, 3096, 1, 0, 0, 0, 3096, 3099, 1, 0, 0, 0, 3097, 3095, 1, 0, 0, 0, 3098, 3090, 1, 0, 0, 0, 3098, 3099, 1, 0, 0, 0, 3099, 3100, 1, 0, 0, 0, 3100, 3101, 5, 465, 0, 0, 3101, 353, 1, 0, 0, 0, 3102, 3103, 7, 18, 0, 0, 3103, 355, 1, 0, 0, 0, 3104, 3105, 5, 464, 0, 0, 3105, 3110, 3, 358, 179, 0, 3106, 3107, 5, 462, 0, 0, 3107, 3109, 3, 358, 179, 0, 3108, 3106, 1, 0, 0, 0, 3109, 3112, 1, 0, 0, 0, 3110, 3108, 1, 0, 0, 0, 3110, 3111, 1, 0, 0, 0, 3111, 3113, 1, 0, 0, 0, 3112, 3110, 1, 0, 0, 0, 3113, 3114, 5, 465, 0, 0, 3114, 357, 1, 0, 0, 0, 3115, 3116, 5, 200, 0, 0, 3116, 3117, 5, 470, 0, 0, 3117, 3118, 5, 466, 0, 0, 3118, 3119, 3, 314, 157, 0, 3119, 3120, 5, 467, 0, 0, 3120, 3143, 1, 0, 0, 0, 3121, 3122, 5, 201, 0, 0, 3122, 3123, 5, 470, 0, 0, 3123, 3124, 5, 466, 0, 0, 3124, 3125, 3, 322, 161, 0, 3125, 3126, 5, 467, 0, 0, 3126, 3143, 1, 0, 0, 0, 3127, 3128, 5, 162, 0, 0, 3128, 3129, 5, 470, 0, 0, 3129, 3143, 5, 478, 0, 0, 3130, 3131, 5, 35, 0, 0, 3131, 3134, 5, 470, 0, 0, 3132, 3135, 3, 646, 323, 0, 3133, 3135, 5, 478, 0, 0, 3134, 3132, 1, 0, 0, 0, 3134, 3133, 1, 0, 0, 0, 3135, 3143, 1, 0, 0, 0, 3136, 3137, 5, 214, 0, 0, 3137, 3138, 5, 470, 0, 0, 3138, 3143, 5, 478, 0, 0, 3139, 3140, 5, 215, 0, 0, 3140, 3141, 5, 470, 0, 0, 3141, 3143, 5, 478, 0, 0, 3142, 3115, 1, 0, 0, 0, 3142, 3121, 1, 0, 0, 0, 3142, 3127, 1, 0, 0, 0, 3142, 3130, 1, 0, 0, 0, 3142, 3136, 1, 0, 0, 0, 3142, 3139, 1, 0, 0, 0, 3143, 359, 1, 0, 0, 0, 3144, 3145, 5, 464, 0, 0, 3145, 3150, 3, 362, 181, 0, 3146, 3147, 5, 462, 0, 0, 3147, 3149, 3, 362, 181, 0, 3148, 3146, 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, 5, 465, 0, 0, 3154, 361, 1, 0, 0, 0, 3155, 3156, 5, 200, 0, 0, 3156, 3157, 5, 470, 0, 0, 3157, 3158, 5, 466, 0, 0, 3158, 3159, 3, 318, 159, 0, 3159, 3160, 5, 467, 0, 0, 3160, 3171, 1, 0, 0, 0, 3161, 3162, 5, 201, 0, 0, 3162, 3163, 5, 470, 0, 0, 3163, 3164, 5, 466, 0, 0, 3164, 3165, 3, 322, 161, 0, 3165, 3166, 5, 467, 0, 0, 3166, 3171, 1, 0, 0, 0, 3167, 3168, 5, 215, 0, 0, 3168, 3169, 5, 470, 0, 0, 3169, 3171, 5, 478, 0, 0, 3170, 3155, 1, 0, 0, 0, 3170, 3161, 1, 0, 0, 0, 3170, 3167, 1, 0, 0, 0, 3171, 363, 1, 0, 0, 0, 3172, 3175, 3, 368, 184, 0, 3173, 3175, 3, 366, 183, 0, 3174, 3172, 1, 0, 0, 0, 3174, 3173, 1, 0, 0, 0, 3175, 3178, 1, 0, 0, 0, 3176, 3174, 1, 0, 0, 0, 3176, 3177, 1, 0, 0, 0, 3177, 365, 1, 0, 0, 0, 3178, 3176, 1, 0, 0, 0, 3179, 3180, 5, 66, 0, 0, 3180, 3181, 5, 377, 0, 0, 3181, 3184, 3, 648, 324, 0, 3182, 3183, 5, 75, 0, 0, 3183, 3185, 3, 648, 324, 0, 3184, 3182, 1, 0, 0, 0, 3184, 3185, 1, 0, 0, 0, 3185, 367, 1, 0, 0, 0, 3186, 3187, 3, 370, 185, 0, 3187, 3189, 5, 482, 0, 0, 3188, 3190, 3, 372, 186, 0, 3189, 3188, 1, 0, 0, 0, 3189, 3190, 1, 0, 0, 0, 3190, 3192, 1, 0, 0, 0, 3191, 3193, 3, 410, 205, 0, 3192, 3191, 1, 0, 0, 0, 3192, 3193, 1, 0, 0, 0, 3193, 369, 1, 0, 0, 0, 3194, 3195, 7, 19, 0, 0, 3195, 371, 1, 0, 0, 0, 3196, 3197, 5, 464, 0, 0, 3197, 3202, 3, 374, 187, 0, 3198, 3199, 5, 462, 0, 0, 3199, 3201, 3, 374, 187, 0, 3200, 3198, 1, 0, 0, 0, 3201, 3204, 1, 0, 0, 0, 3202, 3200, 1, 0, 0, 0, 3202, 3203, 1, 0, 0, 0, 3203, 3205, 1, 0, 0, 0, 3204, 3202, 1, 0, 0, 0, 3205, 3206, 5, 465, 0, 0, 3206, 373, 1, 0, 0, 0, 3207, 3208, 5, 189, 0, 0, 3208, 3209, 5, 470, 0, 0, 3209, 3283, 3, 380, 190, 0, 3210, 3211, 5, 38, 0, 0, 3211, 3212, 5, 470, 0, 0, 3212, 3283, 3, 388, 194, 0, 3213, 3214, 5, 196, 0, 0, 3214, 3215, 5, 470, 0, 0, 3215, 3283, 3, 388, 194, 0, 3216, 3217, 5, 114, 0, 0, 3217, 3218, 5, 470, 0, 0, 3218, 3283, 3, 382, 191, 0, 3219, 3220, 5, 186, 0, 0, 3220, 3221, 5, 470, 0, 0, 3221, 3283, 3, 390, 195, 0, 3222, 3223, 5, 166, 0, 0, 3223, 3224, 5, 470, 0, 0, 3224, 3283, 5, 478, 0, 0, 3225, 3226, 5, 197, 0, 0, 3226, 3227, 5, 470, 0, 0, 3227, 3283, 3, 388, 194, 0, 3228, 3229, 5, 194, 0, 0, 3229, 3230, 5, 470, 0, 0, 3230, 3283, 3, 390, 195, 0, 3231, 3232, 5, 195, 0, 0, 3232, 3233, 5, 470, 0, 0, 3233, 3283, 3, 396, 198, 0, 3234, 3235, 5, 198, 0, 0, 3235, 3236, 5, 470, 0, 0, 3236, 3283, 3, 392, 196, 0, 3237, 3238, 5, 199, 0, 0, 3238, 3239, 5, 470, 0, 0, 3239, 3283, 3, 392, 196, 0, 3240, 3241, 5, 205, 0, 0, 3241, 3242, 5, 470, 0, 0, 3242, 3283, 3, 398, 199, 0, 3243, 3244, 5, 203, 0, 0, 3244, 3245, 5, 470, 0, 0, 3245, 3283, 5, 478, 0, 0, 3246, 3247, 5, 204, 0, 0, 3247, 3248, 5, 470, 0, 0, 3248, 3283, 5, 478, 0, 0, 3249, 3250, 5, 202, 0, 0, 3250, 3251, 5, 470, 0, 0, 3251, 3283, 3, 400, 200, 0, 3252, 3253, 5, 191, 0, 0, 3253, 3254, 5, 470, 0, 0, 3254, 3283, 3, 402, 201, 0, 3255, 3256, 5, 34, 0, 0, 3256, 3257, 5, 470, 0, 0, 3257, 3283, 3, 646, 323, 0, 3258, 3259, 5, 220, 0, 0, 3259, 3260, 5, 470, 0, 0, 3260, 3283, 3, 378, 189, 0, 3261, 3262, 5, 221, 0, 0, 3262, 3263, 5, 470, 0, 0, 3263, 3283, 3, 376, 188, 0, 3264, 3265, 5, 208, 0, 0, 3265, 3266, 5, 470, 0, 0, 3266, 3283, 3, 406, 203, 0, 3267, 3268, 5, 211, 0, 0, 3268, 3269, 5, 470, 0, 0, 3269, 3283, 5, 480, 0, 0, 3270, 3271, 5, 212, 0, 0, 3271, 3272, 5, 470, 0, 0, 3272, 3283, 5, 480, 0, 0, 3273, 3274, 5, 227, 0, 0, 3274, 3275, 5, 470, 0, 0, 3275, 3283, 3, 404, 202, 0, 3276, 3277, 5, 188, 0, 0, 3277, 3278, 5, 470, 0, 0, 3278, 3283, 3, 404, 202, 0, 3279, 3280, 5, 482, 0, 0, 3280, 3281, 5, 470, 0, 0, 3281, 3283, 3, 404, 202, 0, 3282, 3207, 1, 0, 0, 0, 3282, 3210, 1, 0, 0, 0, 3282, 3213, 1, 0, 0, 0, 3282, 3216, 1, 0, 0, 0, 3282, 3219, 1, 0, 0, 0, 3282, 3222, 1, 0, 0, 0, 3282, 3225, 1, 0, 0, 0, 3282, 3228, 1, 0, 0, 0, 3282, 3231, 1, 0, 0, 0, 3282, 3234, 1, 0, 0, 0, 3282, 3237, 1, 0, 0, 0, 3282, 3240, 1, 0, 0, 0, 3282, 3243, 1, 0, 0, 0, 3282, 3246, 1, 0, 0, 0, 3282, 3249, 1, 0, 0, 0, 3282, 3252, 1, 0, 0, 0, 3282, 3255, 1, 0, 0, 0, 3282, 3258, 1, 0, 0, 0, 3282, 3261, 1, 0, 0, 0, 3282, 3264, 1, 0, 0, 0, 3282, 3267, 1, 0, 0, 0, 3282, 3270, 1, 0, 0, 0, 3282, 3273, 1, 0, 0, 0, 3282, 3276, 1, 0, 0, 0, 3282, 3279, 1, 0, 0, 0, 3283, 375, 1, 0, 0, 0, 3284, 3285, 7, 20, 0, 0, 3285, 377, 1, 0, 0, 0, 3286, 3287, 5, 468, 0, 0, 3287, 3292, 3, 646, 323, 0, 3288, 3289, 5, 462, 0, 0, 3289, 3291, 3, 646, 323, 0, 3290, 3288, 1, 0, 0, 0, 3291, 3294, 1, 0, 0, 0, 3292, 3290, 1, 0, 0, 0, 3292, 3293, 1, 0, 0, 0, 3293, 3295, 1, 0, 0, 0, 3294, 3292, 1, 0, 0, 0, 3295, 3296, 5, 469, 0, 0, 3296, 379, 1, 0, 0, 0, 3297, 3344, 5, 481, 0, 0, 3298, 3300, 5, 343, 0, 0, 3299, 3301, 5, 70, 0, 0, 3300, 3299, 1, 0, 0, 0, 3300, 3301, 1, 0, 0, 0, 3301, 3302, 1, 0, 0, 0, 3302, 3316, 3, 646, 323, 0, 3303, 3314, 5, 71, 0, 0, 3304, 3310, 3, 328, 164, 0, 3305, 3306, 3, 330, 165, 0, 3306, 3307, 3, 328, 164, 0, 3307, 3309, 1, 0, 0, 0, 3308, 3305, 1, 0, 0, 0, 3309, 3312, 1, 0, 0, 0, 3310, 3308, 1, 0, 0, 0, 3310, 3311, 1, 0, 0, 0, 3311, 3315, 1, 0, 0, 0, 3312, 3310, 1, 0, 0, 0, 3313, 3315, 3, 608, 304, 0, 3314, 3304, 1, 0, 0, 0, 3314, 3313, 1, 0, 0, 0, 3315, 3317, 1, 0, 0, 0, 3316, 3303, 1, 0, 0, 0, 3316, 3317, 1, 0, 0, 0, 3317, 3327, 1, 0, 0, 0, 3318, 3319, 5, 10, 0, 0, 3319, 3324, 3, 326, 163, 0, 3320, 3321, 5, 462, 0, 0, 3321, 3323, 3, 326, 163, 0, 3322, 3320, 1, 0, 0, 0, 3323, 3326, 1, 0, 0, 0, 3324, 3322, 1, 0, 0, 0, 3324, 3325, 1, 0, 0, 0, 3325, 3328, 1, 0, 0, 0, 3326, 3324, 1, 0, 0, 0, 3327, 3318, 1, 0, 0, 0, 3327, 3328, 1, 0, 0, 0, 3328, 3344, 1, 0, 0, 0, 3329, 3330, 5, 30, 0, 0, 3330, 3332, 3, 646, 323, 0, 3331, 3333, 3, 384, 192, 0, 3332, 3331, 1, 0, 0, 0, 3332, 3333, 1, 0, 0, 0, 3333, 3344, 1, 0, 0, 0, 3334, 3335, 5, 31, 0, 0, 3335, 3337, 3, 646, 323, 0, 3336, 3338, 3, 384, 192, 0, 3337, 3336, 1, 0, 0, 0, 3337, 3338, 1, 0, 0, 0, 3338, 3344, 1, 0, 0, 0, 3339, 3340, 5, 27, 0, 0, 3340, 3344, 3, 388, 194, 0, 3341, 3342, 5, 191, 0, 0, 3342, 3344, 5, 482, 0, 0, 3343, 3297, 1, 0, 0, 0, 3343, 3298, 1, 0, 0, 0, 3343, 3329, 1, 0, 0, 0, 3343, 3334, 1, 0, 0, 0, 3343, 3339, 1, 0, 0, 0, 3343, 3341, 1, 0, 0, 0, 3344, 381, 1, 0, 0, 0, 3345, 3347, 5, 229, 0, 0, 3346, 3348, 5, 231, 0, 0, 3347, 3346, 1, 0, 0, 0, 3347, 3348, 1, 0, 0, 0, 3348, 3384, 1, 0, 0, 0, 3349, 3351, 5, 230, 0, 0, 3350, 3352, 5, 231, 0, 0, 3351, 3350, 1, 0, 0, 0, 3351, 3352, 1, 0, 0, 0, 3352, 3384, 1, 0, 0, 0, 3353, 3384, 5, 231, 0, 0, 3354, 3384, 5, 234, 0, 0, 3355, 3357, 5, 99, 0, 0, 3356, 3358, 5, 231, 0, 0, 3357, 3356, 1, 0, 0, 0, 3357, 3358, 1, 0, 0, 0, 3358, 3384, 1, 0, 0, 0, 3359, 3360, 5, 235, 0, 0, 3360, 3363, 3, 646, 323, 0, 3361, 3362, 5, 80, 0, 0, 3362, 3364, 3, 382, 191, 0, 3363, 3361, 1, 0, 0, 0, 3363, 3364, 1, 0, 0, 0, 3364, 3384, 1, 0, 0, 0, 3365, 3366, 5, 232, 0, 0, 3366, 3368, 3, 646, 323, 0, 3367, 3369, 3, 384, 192, 0, 3368, 3367, 1, 0, 0, 0, 3368, 3369, 1, 0, 0, 0, 3369, 3384, 1, 0, 0, 0, 3370, 3371, 5, 30, 0, 0, 3371, 3373, 3, 646, 323, 0, 3372, 3374, 3, 384, 192, 0, 3373, 3372, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3384, 1, 0, 0, 0, 3375, 3376, 5, 31, 0, 0, 3376, 3378, 3, 646, 323, 0, 3377, 3379, 3, 384, 192, 0, 3378, 3377, 1, 0, 0, 0, 3378, 3379, 1, 0, 0, 0, 3379, 3384, 1, 0, 0, 0, 3380, 3381, 5, 238, 0, 0, 3381, 3384, 5, 478, 0, 0, 3382, 3384, 5, 239, 0, 0, 3383, 3345, 1, 0, 0, 0, 3383, 3349, 1, 0, 0, 0, 3383, 3353, 1, 0, 0, 0, 3383, 3354, 1, 0, 0, 0, 3383, 3355, 1, 0, 0, 0, 3383, 3359, 1, 0, 0, 0, 3383, 3365, 1, 0, 0, 0, 3383, 3370, 1, 0, 0, 0, 3383, 3375, 1, 0, 0, 0, 3383, 3380, 1, 0, 0, 0, 3383, 3382, 1, 0, 0, 0, 3384, 383, 1, 0, 0, 0, 3385, 3386, 5, 464, 0, 0, 3386, 3391, 3, 386, 193, 0, 3387, 3388, 5, 462, 0, 0, 3388, 3390, 3, 386, 193, 0, 3389, 3387, 1, 0, 0, 0, 3390, 3393, 1, 0, 0, 0, 3391, 3389, 1, 0, 0, 0, 3391, 3392, 1, 0, 0, 0, 3392, 3394, 1, 0, 0, 0, 3393, 3391, 1, 0, 0, 0, 3394, 3395, 5, 465, 0, 0, 3395, 385, 1, 0, 0, 0, 3396, 3397, 5, 482, 0, 0, 3397, 3398, 5, 470, 0, 0, 3398, 3403, 3, 608, 304, 0, 3399, 3400, 5, 481, 0, 0, 3400, 3401, 5, 451, 0, 0, 3401, 3403, 3, 608, 304, 0, 3402, 3396, 1, 0, 0, 0, 3402, 3399, 1, 0, 0, 0, 3403, 387, 1, 0, 0, 0, 3404, 3408, 5, 482, 0, 0, 3405, 3408, 5, 484, 0, 0, 3406, 3408, 3, 670, 335, 0, 3407, 3404, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3407, 3406, 1, 0, 0, 0, 3408, 3417, 1, 0, 0, 0, 3409, 3413, 5, 457, 0, 0, 3410, 3414, 5, 482, 0, 0, 3411, 3414, 5, 484, 0, 0, 3412, 3414, 3, 670, 335, 0, 3413, 3410, 1, 0, 0, 0, 3413, 3411, 1, 0, 0, 0, 3413, 3412, 1, 0, 0, 0, 3414, 3416, 1, 0, 0, 0, 3415, 3409, 1, 0, 0, 0, 3416, 3419, 1, 0, 0, 0, 3417, 3415, 1, 0, 0, 0, 3417, 3418, 1, 0, 0, 0, 3418, 389, 1, 0, 0, 0, 3419, 3417, 1, 0, 0, 0, 3420, 3431, 5, 478, 0, 0, 3421, 3431, 3, 388, 194, 0, 3422, 3428, 5, 481, 0, 0, 3423, 3426, 5, 463, 0, 0, 3424, 3427, 5, 482, 0, 0, 3425, 3427, 3, 670, 335, 0, 3426, 3424, 1, 0, 0, 0, 3426, 3425, 1, 0, 0, 0, 3427, 3429, 1, 0, 0, 0, 3428, 3423, 1, 0, 0, 0, 3428, 3429, 1, 0, 0, 0, 3429, 3431, 1, 0, 0, 0, 3430, 3420, 1, 0, 0, 0, 3430, 3421, 1, 0, 0, 0, 3430, 3422, 1, 0, 0, 0, 3431, 391, 1, 0, 0, 0, 3432, 3433, 5, 468, 0, 0, 3433, 3438, 3, 394, 197, 0, 3434, 3435, 5, 462, 0, 0, 3435, 3437, 3, 394, 197, 0, 3436, 3434, 1, 0, 0, 0, 3437, 3440, 1, 0, 0, 0, 3438, 3436, 1, 0, 0, 0, 3438, 3439, 1, 0, 0, 0, 3439, 3441, 1, 0, 0, 0, 3440, 3438, 1, 0, 0, 0, 3441, 3442, 5, 469, 0, 0, 3442, 393, 1, 0, 0, 0, 3443, 3444, 5, 466, 0, 0, 3444, 3445, 5, 480, 0, 0, 3445, 3446, 5, 467, 0, 0, 3446, 3447, 5, 451, 0, 0, 3447, 3448, 3, 608, 304, 0, 3448, 395, 1, 0, 0, 0, 3449, 3450, 7, 21, 0, 0, 3450, 397, 1, 0, 0, 0, 3451, 3452, 7, 22, 0, 0, 3452, 399, 1, 0, 0, 0, 3453, 3454, 7, 23, 0, 0, 3454, 401, 1, 0, 0, 0, 3455, 3456, 7, 24, 0, 0, 3456, 403, 1, 0, 0, 0, 3457, 3481, 5, 478, 0, 0, 3458, 3481, 5, 480, 0, 0, 3459, 3481, 3, 654, 327, 0, 3460, 3481, 3, 646, 323, 0, 3461, 3481, 5, 482, 0, 0, 3462, 3481, 5, 250, 0, 0, 3463, 3481, 5, 251, 0, 0, 3464, 3481, 5, 252, 0, 0, 3465, 3481, 5, 253, 0, 0, 3466, 3481, 5, 254, 0, 0, 3467, 3481, 5, 255, 0, 0, 3468, 3477, 5, 468, 0, 0, 3469, 3474, 3, 608, 304, 0, 3470, 3471, 5, 462, 0, 0, 3471, 3473, 3, 608, 304, 0, 3472, 3470, 1, 0, 0, 0, 3473, 3476, 1, 0, 0, 0, 3474, 3472, 1, 0, 0, 0, 3474, 3475, 1, 0, 0, 0, 3475, 3478, 1, 0, 0, 0, 3476, 3474, 1, 0, 0, 0, 3477, 3469, 1, 0, 0, 0, 3477, 3478, 1, 0, 0, 0, 3478, 3479, 1, 0, 0, 0, 3479, 3481, 5, 469, 0, 0, 3480, 3457, 1, 0, 0, 0, 3480, 3458, 1, 0, 0, 0, 3480, 3459, 1, 0, 0, 0, 3480, 3460, 1, 0, 0, 0, 3480, 3461, 1, 0, 0, 0, 3480, 3462, 1, 0, 0, 0, 3480, 3463, 1, 0, 0, 0, 3480, 3464, 1, 0, 0, 0, 3480, 3465, 1, 0, 0, 0, 3480, 3466, 1, 0, 0, 0, 3480, 3467, 1, 0, 0, 0, 3480, 3468, 1, 0, 0, 0, 3481, 405, 1, 0, 0, 0, 3482, 3483, 5, 468, 0, 0, 3483, 3488, 3, 408, 204, 0, 3484, 3485, 5, 462, 0, 0, 3485, 3487, 3, 408, 204, 0, 3486, 3484, 1, 0, 0, 0, 3487, 3490, 1, 0, 0, 0, 3488, 3486, 1, 0, 0, 0, 3488, 3489, 1, 0, 0, 0, 3489, 3491, 1, 0, 0, 0, 3490, 3488, 1, 0, 0, 0, 3491, 3492, 5, 469, 0, 0, 3492, 3496, 1, 0, 0, 0, 3493, 3494, 5, 468, 0, 0, 3494, 3496, 5, 469, 0, 0, 3495, 3482, 1, 0, 0, 0, 3495, 3493, 1, 0, 0, 0, 3496, 407, 1, 0, 0, 0, 3497, 3498, 5, 478, 0, 0, 3498, 3499, 5, 470, 0, 0, 3499, 3507, 5, 478, 0, 0, 3500, 3501, 5, 478, 0, 0, 3501, 3502, 5, 470, 0, 0, 3502, 3507, 5, 92, 0, 0, 3503, 3504, 5, 478, 0, 0, 3504, 3505, 5, 470, 0, 0, 3505, 3507, 5, 446, 0, 0, 3506, 3497, 1, 0, 0, 0, 3506, 3500, 1, 0, 0, 0, 3506, 3503, 1, 0, 0, 0, 3507, 409, 1, 0, 0, 0, 3508, 3509, 5, 466, 0, 0, 3509, 3510, 3, 364, 182, 0, 3510, 3511, 5, 467, 0, 0, 3511, 411, 1, 0, 0, 0, 3512, 3513, 5, 36, 0, 0, 3513, 3515, 3, 646, 323, 0, 3514, 3516, 3, 414, 207, 0, 3515, 3514, 1, 0, 0, 0, 3515, 3516, 1, 0, 0, 0, 3516, 3517, 1, 0, 0, 0, 3517, 3521, 5, 95, 0, 0, 3518, 3520, 3, 418, 209, 0, 3519, 3518, 1, 0, 0, 0, 3520, 3523, 1, 0, 0, 0, 3521, 3519, 1, 0, 0, 0, 3521, 3522, 1, 0, 0, 0, 3522, 3524, 1, 0, 0, 0, 3523, 3521, 1, 0, 0, 0, 3524, 3525, 5, 82, 0, 0, 3525, 413, 1, 0, 0, 0, 3526, 3528, 3, 416, 208, 0, 3527, 3526, 1, 0, 0, 0, 3528, 3529, 1, 0, 0, 0, 3529, 3527, 1, 0, 0, 0, 3529, 3530, 1, 0, 0, 0, 3530, 415, 1, 0, 0, 0, 3531, 3532, 5, 393, 0, 0, 3532, 3533, 5, 478, 0, 0, 3533, 417, 1, 0, 0, 0, 3534, 3535, 5, 33, 0, 0, 3535, 3538, 3, 646, 323, 0, 3536, 3537, 5, 186, 0, 0, 3537, 3539, 5, 478, 0, 0, 3538, 3536, 1, 0, 0, 0, 3538, 3539, 1, 0, 0, 0, 3539, 419, 1, 0, 0, 0, 3540, 3541, 5, 343, 0, 0, 3541, 3542, 5, 342, 0, 0, 3542, 3544, 3, 646, 323, 0, 3543, 3545, 3, 422, 211, 0, 3544, 3543, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 3544, 1, 0, 0, 0, 3546, 3547, 1, 0, 0, 0, 3547, 3556, 1, 0, 0, 0, 3548, 3552, 5, 95, 0, 0, 3549, 3551, 3, 424, 212, 0, 3550, 3549, 1, 0, 0, 0, 3551, 3554, 1, 0, 0, 0, 3552, 3550, 1, 0, 0, 0, 3552, 3553, 1, 0, 0, 0, 3553, 3555, 1, 0, 0, 0, 3554, 3552, 1, 0, 0, 0, 3555, 3557, 5, 82, 0, 0, 3556, 3548, 1, 0, 0, 0, 3556, 3557, 1, 0, 0, 0, 3557, 421, 1, 0, 0, 0, 3558, 3559, 5, 404, 0, 0, 3559, 3586, 5, 478, 0, 0, 3560, 3561, 5, 342, 0, 0, 3561, 3565, 5, 257, 0, 0, 3562, 3566, 5, 478, 0, 0, 3563, 3564, 5, 471, 0, 0, 3564, 3566, 3, 646, 323, 0, 3565, 3562, 1, 0, 0, 0, 3565, 3563, 1, 0, 0, 0, 3566, 3586, 1, 0, 0, 0, 3567, 3568, 5, 62, 0, 0, 3568, 3586, 5, 478, 0, 0, 3569, 3570, 5, 63, 0, 0, 3570, 3586, 5, 480, 0, 0, 3571, 3572, 5, 343, 0, 0, 3572, 3586, 5, 478, 0, 0, 3573, 3577, 5, 340, 0, 0, 3574, 3578, 5, 478, 0, 0, 3575, 3576, 5, 471, 0, 0, 3576, 3578, 3, 646, 323, 0, 3577, 3574, 1, 0, 0, 0, 3577, 3575, 1, 0, 0, 0, 3578, 3586, 1, 0, 0, 0, 3579, 3583, 5, 341, 0, 0, 3580, 3584, 5, 478, 0, 0, 3581, 3582, 5, 471, 0, 0, 3582, 3584, 3, 646, 323, 0, 3583, 3580, 1, 0, 0, 0, 3583, 3581, 1, 0, 0, 0, 3584, 3586, 1, 0, 0, 0, 3585, 3558, 1, 0, 0, 0, 3585, 3560, 1, 0, 0, 0, 3585, 3567, 1, 0, 0, 0, 3585, 3569, 1, 0, 0, 0, 3585, 3571, 1, 0, 0, 0, 3585, 3573, 1, 0, 0, 0, 3585, 3579, 1, 0, 0, 0, 3586, 423, 1, 0, 0, 0, 3587, 3588, 5, 344, 0, 0, 3588, 3589, 3, 648, 324, 0, 3589, 3590, 5, 418, 0, 0, 3590, 3602, 7, 25, 0, 0, 3591, 3592, 5, 358, 0, 0, 3592, 3593, 3, 648, 324, 0, 3593, 3594, 5, 470, 0, 0, 3594, 3598, 3, 98, 49, 0, 3595, 3596, 5, 290, 0, 0, 3596, 3599, 5, 478, 0, 0, 3597, 3599, 5, 283, 0, 0, 3598, 3595, 1, 0, 0, 0, 3598, 3597, 1, 0, 0, 0, 3598, 3599, 1, 0, 0, 0, 3599, 3601, 1, 0, 0, 0, 3600, 3591, 1, 0, 0, 0, 3601, 3604, 1, 0, 0, 0, 3602, 3600, 1, 0, 0, 0, 3602, 3603, 1, 0, 0, 0, 3603, 3621, 1, 0, 0, 0, 3604, 3602, 1, 0, 0, 0, 3605, 3606, 5, 76, 0, 0, 3606, 3619, 3, 646, 323, 0, 3607, 3608, 5, 345, 0, 0, 3608, 3609, 5, 464, 0, 0, 3609, 3614, 3, 426, 213, 0, 3610, 3611, 5, 462, 0, 0, 3611, 3613, 3, 426, 213, 0, 3612, 3610, 1, 0, 0, 0, 3613, 3616, 1, 0, 0, 0, 3614, 3612, 1, 0, 0, 0, 3614, 3615, 1, 0, 0, 0, 3615, 3617, 1, 0, 0, 0, 3616, 3614, 1, 0, 0, 0, 3617, 3618, 5, 465, 0, 0, 3618, 3620, 1, 0, 0, 0, 3619, 3607, 1, 0, 0, 0, 3619, 3620, 1, 0, 0, 0, 3620, 3622, 1, 0, 0, 0, 3621, 3605, 1, 0, 0, 0, 3621, 3622, 1, 0, 0, 0, 3622, 3623, 1, 0, 0, 0, 3623, 3624, 5, 461, 0, 0, 3624, 425, 1, 0, 0, 0, 3625, 3626, 3, 648, 324, 0, 3626, 3627, 5, 75, 0, 0, 3627, 3628, 3, 648, 324, 0, 3628, 427, 1, 0, 0, 0, 3629, 3630, 5, 37, 0, 0, 3630, 3631, 3, 646, 323, 0, 3631, 3632, 5, 404, 0, 0, 3632, 3633, 3, 98, 49, 0, 3633, 3634, 5, 290, 0, 0, 3634, 3636, 3, 650, 325, 0, 3635, 3637, 3, 430, 215, 0, 3636, 3635, 1, 0, 0, 0, 3636, 3637, 1, 0, 0, 0, 3637, 429, 1, 0, 0, 0, 3638, 3640, 3, 432, 216, 0, 3639, 3638, 1, 0, 0, 0, 3640, 3641, 1, 0, 0, 0, 3641, 3639, 1, 0, 0, 0, 3641, 3642, 1, 0, 0, 0, 3642, 431, 1, 0, 0, 0, 3643, 3644, 5, 393, 0, 0, 3644, 3645, 5, 478, 0, 0, 3645, 433, 1, 0, 0, 0, 3646, 3647, 5, 305, 0, 0, 3647, 3648, 5, 331, 0, 0, 3648, 3649, 3, 646, 323, 0, 3649, 3650, 3, 436, 218, 0, 3650, 3654, 5, 95, 0, 0, 3651, 3653, 3, 442, 221, 0, 3652, 3651, 1, 0, 0, 0, 3653, 3656, 1, 0, 0, 0, 3654, 3652, 1, 0, 0, 0, 3654, 3655, 1, 0, 0, 0, 3655, 3657, 1, 0, 0, 0, 3656, 3654, 1, 0, 0, 0, 3657, 3658, 5, 82, 0, 0, 3658, 435, 1, 0, 0, 0, 3659, 3661, 3, 438, 219, 0, 3660, 3659, 1, 0, 0, 0, 3661, 3662, 1, 0, 0, 0, 3662, 3660, 1, 0, 0, 0, 3662, 3663, 1, 0, 0, 0, 3663, 437, 1, 0, 0, 0, 3664, 3665, 5, 309, 0, 0, 3665, 3666, 5, 214, 0, 0, 3666, 3674, 5, 478, 0, 0, 3667, 3668, 5, 318, 0, 0, 3668, 3674, 5, 480, 0, 0, 3669, 3670, 5, 311, 0, 0, 3670, 3674, 3, 440, 220, 0, 3671, 3672, 5, 393, 0, 0, 3672, 3674, 5, 478, 0, 0, 3673, 3664, 1, 0, 0, 0, 3673, 3667, 1, 0, 0, 0, 3673, 3669, 1, 0, 0, 0, 3673, 3671, 1, 0, 0, 0, 3674, 439, 1, 0, 0, 0, 3675, 3676, 5, 312, 0, 0, 3676, 3677, 5, 340, 0, 0, 3677, 3678, 5, 478, 0, 0, 3678, 3679, 5, 341, 0, 0, 3679, 3684, 5, 478, 0, 0, 3680, 3681, 5, 314, 0, 0, 3681, 3684, 5, 478, 0, 0, 3682, 3684, 5, 408, 0, 0, 3683, 3675, 1, 0, 0, 0, 3683, 3680, 1, 0, 0, 0, 3683, 3682, 1, 0, 0, 0, 3684, 441, 1, 0, 0, 0, 3685, 3686, 5, 315, 0, 0, 3686, 3687, 5, 482, 0, 0, 3687, 3688, 5, 316, 0, 0, 3688, 3689, 3, 444, 222, 0, 3689, 3690, 5, 317, 0, 0, 3690, 3692, 5, 478, 0, 0, 3691, 3693, 3, 446, 223, 0, 3692, 3691, 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 443, 1, 0, 0, 0, 3694, 3695, 7, 13, 0, 0, 3695, 445, 1, 0, 0, 0, 3696, 3698, 3, 448, 224, 0, 3697, 3696, 1, 0, 0, 0, 3698, 3699, 1, 0, 0, 0, 3699, 3697, 1, 0, 0, 0, 3699, 3700, 1, 0, 0, 0, 3700, 447, 1, 0, 0, 0, 3701, 3702, 5, 319, 0, 0, 3702, 3710, 5, 478, 0, 0, 3703, 3704, 5, 320, 0, 0, 3704, 3710, 3, 450, 225, 0, 3705, 3706, 5, 358, 0, 0, 3706, 3710, 3, 452, 226, 0, 3707, 3708, 5, 318, 0, 0, 3708, 3710, 5, 480, 0, 0, 3709, 3701, 1, 0, 0, 0, 3709, 3703, 1, 0, 0, 0, 3709, 3705, 1, 0, 0, 0, 3709, 3707, 1, 0, 0, 0, 3710, 449, 1, 0, 0, 0, 3711, 3712, 5, 324, 0, 0, 3712, 3713, 5, 480, 0, 0, 3713, 3714, 3, 98, 49, 0, 3714, 451, 1, 0, 0, 0, 3715, 3716, 5, 482, 0, 0, 3716, 3717, 5, 470, 0, 0, 3717, 3720, 3, 98, 49, 0, 3718, 3719, 5, 284, 0, 0, 3719, 3721, 7, 26, 0, 0, 3720, 3718, 1, 0, 0, 0, 3720, 3721, 1, 0, 0, 0, 3721, 453, 1, 0, 0, 0, 3722, 3723, 5, 41, 0, 0, 3723, 3724, 5, 482, 0, 0, 3724, 3725, 5, 92, 0, 0, 3725, 3726, 3, 646, 323, 0, 3726, 3727, 5, 464, 0, 0, 3727, 3728, 3, 106, 53, 0, 3728, 3729, 5, 465, 0, 0, 3729, 455, 1, 0, 0, 0, 3730, 3731, 5, 308, 0, 0, 3731, 3732, 5, 331, 0, 0, 3732, 3733, 3, 646, 323, 0, 3733, 3734, 5, 464, 0, 0, 3734, 3739, 3, 462, 231, 0, 3735, 3736, 5, 462, 0, 0, 3736, 3738, 3, 462, 231, 0, 3737, 3735, 1, 0, 0, 0, 3738, 3741, 1, 0, 0, 0, 3739, 3737, 1, 0, 0, 0, 3739, 3740, 1, 0, 0, 0, 3740, 3742, 1, 0, 0, 0, 3741, 3739, 1, 0, 0, 0, 3742, 3744, 5, 465, 0, 0, 3743, 3745, 3, 482, 241, 0, 3744, 3743, 1, 0, 0, 0, 3744, 3745, 1, 0, 0, 0, 3745, 457, 1, 0, 0, 0, 3746, 3747, 5, 308, 0, 0, 3747, 3748, 5, 306, 0, 0, 3748, 3749, 3, 646, 323, 0, 3749, 3750, 5, 464, 0, 0, 3750, 3755, 3, 462, 231, 0, 3751, 3752, 5, 462, 0, 0, 3752, 3754, 3, 462, 231, 0, 3753, 3751, 1, 0, 0, 0, 3754, 3757, 1, 0, 0, 0, 3755, 3753, 1, 0, 0, 0, 3755, 3756, 1, 0, 0, 0, 3756, 3758, 1, 0, 0, 0, 3757, 3755, 1, 0, 0, 0, 3758, 3760, 5, 465, 0, 0, 3759, 3761, 3, 466, 233, 0, 3760, 3759, 1, 0, 0, 0, 3760, 3761, 1, 0, 0, 0, 3761, 3770, 1, 0, 0, 0, 3762, 3766, 5, 466, 0, 0, 3763, 3765, 3, 470, 235, 0, 3764, 3763, 1, 0, 0, 0, 3765, 3768, 1, 0, 0, 0, 3766, 3764, 1, 0, 0, 0, 3766, 3767, 1, 0, 0, 0, 3767, 3769, 1, 0, 0, 0, 3768, 3766, 1, 0, 0, 0, 3769, 3771, 5, 467, 0, 0, 3770, 3762, 1, 0, 0, 0, 3770, 3771, 1, 0, 0, 0, 3771, 459, 1, 0, 0, 0, 3772, 3782, 5, 478, 0, 0, 3773, 3782, 5, 480, 0, 0, 3774, 3782, 5, 291, 0, 0, 3775, 3782, 5, 292, 0, 0, 3776, 3778, 5, 30, 0, 0, 3777, 3779, 3, 646, 323, 0, 3778, 3777, 1, 0, 0, 0, 3778, 3779, 1, 0, 0, 0, 3779, 3782, 1, 0, 0, 0, 3780, 3782, 3, 646, 323, 0, 3781, 3772, 1, 0, 0, 0, 3781, 3773, 1, 0, 0, 0, 3781, 3774, 1, 0, 0, 0, 3781, 3775, 1, 0, 0, 0, 3781, 3776, 1, 0, 0, 0, 3781, 3780, 1, 0, 0, 0, 3782, 461, 1, 0, 0, 0, 3783, 3784, 3, 648, 324, 0, 3784, 3785, 5, 470, 0, 0, 3785, 3786, 3, 460, 230, 0, 3786, 463, 1, 0, 0, 0, 3787, 3788, 3, 648, 324, 0, 3788, 3789, 5, 451, 0, 0, 3789, 3790, 3, 460, 230, 0, 3790, 465, 1, 0, 0, 0, 3791, 3792, 5, 311, 0, 0, 3792, 3797, 3, 468, 234, 0, 3793, 3794, 5, 462, 0, 0, 3794, 3796, 3, 468, 234, 0, 3795, 3793, 1, 0, 0, 0, 3796, 3799, 1, 0, 0, 0, 3797, 3795, 1, 0, 0, 0, 3797, 3798, 1, 0, 0, 0, 3798, 467, 1, 0, 0, 0, 3799, 3797, 1, 0, 0, 0, 3800, 3809, 5, 312, 0, 0, 3801, 3809, 5, 336, 0, 0, 3802, 3809, 5, 337, 0, 0, 3803, 3805, 5, 30, 0, 0, 3804, 3806, 3, 646, 323, 0, 3805, 3804, 1, 0, 0, 0, 3805, 3806, 1, 0, 0, 0, 3806, 3809, 1, 0, 0, 0, 3807, 3809, 5, 482, 0, 0, 3808, 3800, 1, 0, 0, 0, 3808, 3801, 1, 0, 0, 0, 3808, 3802, 1, 0, 0, 0, 3808, 3803, 1, 0, 0, 0, 3808, 3807, 1, 0, 0, 0, 3809, 469, 1, 0, 0, 0, 3810, 3811, 5, 333, 0, 0, 3811, 3812, 5, 23, 0, 0, 3812, 3815, 3, 646, 323, 0, 3813, 3814, 5, 75, 0, 0, 3814, 3816, 5, 478, 0, 0, 3815, 3813, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, 3828, 1, 0, 0, 0, 3817, 3818, 5, 464, 0, 0, 3818, 3823, 3, 462, 231, 0, 3819, 3820, 5, 462, 0, 0, 3820, 3822, 3, 462, 231, 0, 3821, 3819, 1, 0, 0, 0, 3822, 3825, 1, 0, 0, 0, 3823, 3821, 1, 0, 0, 0, 3823, 3824, 1, 0, 0, 0, 3824, 3826, 1, 0, 0, 0, 3825, 3823, 1, 0, 0, 0, 3826, 3827, 5, 465, 0, 0, 3827, 3829, 1, 0, 0, 0, 3828, 3817, 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, 3831, 1, 0, 0, 0, 3830, 3832, 3, 472, 236, 0, 3831, 3830, 1, 0, 0, 0, 3831, 3832, 1, 0, 0, 0, 3832, 3834, 1, 0, 0, 0, 3833, 3835, 5, 461, 0, 0, 3834, 3833, 1, 0, 0, 0, 3834, 3835, 1, 0, 0, 0, 3835, 471, 1, 0, 0, 0, 3836, 3837, 5, 334, 0, 0, 3837, 3847, 5, 464, 0, 0, 3838, 3848, 5, 456, 0, 0, 3839, 3844, 3, 474, 237, 0, 3840, 3841, 5, 462, 0, 0, 3841, 3843, 3, 474, 237, 0, 3842, 3840, 1, 0, 0, 0, 3843, 3846, 1, 0, 0, 0, 3844, 3842, 1, 0, 0, 0, 3844, 3845, 1, 0, 0, 0, 3845, 3848, 1, 0, 0, 0, 3846, 3844, 1, 0, 0, 0, 3847, 3838, 1, 0, 0, 0, 3847, 3839, 1, 0, 0, 0, 3848, 3849, 1, 0, 0, 0, 3849, 3850, 5, 465, 0, 0, 3850, 473, 1, 0, 0, 0, 3851, 3854, 5, 482, 0, 0, 3852, 3853, 5, 75, 0, 0, 3853, 3855, 5, 478, 0, 0, 3854, 3852, 1, 0, 0, 0, 3854, 3855, 1, 0, 0, 0, 3855, 3857, 1, 0, 0, 0, 3856, 3858, 3, 476, 238, 0, 3857, 3856, 1, 0, 0, 0, 3857, 3858, 1, 0, 0, 0, 3858, 475, 1, 0, 0, 0, 3859, 3860, 5, 464, 0, 0, 3860, 3865, 5, 482, 0, 0, 3861, 3862, 5, 462, 0, 0, 3862, 3864, 5, 482, 0, 0, 3863, 3861, 1, 0, 0, 0, 3864, 3867, 1, 0, 0, 0, 3865, 3863, 1, 0, 0, 0, 3865, 3866, 1, 0, 0, 0, 3866, 3868, 1, 0, 0, 0, 3867, 3865, 1, 0, 0, 0, 3868, 3869, 5, 465, 0, 0, 3869, 477, 1, 0, 0, 0, 3870, 3871, 5, 26, 0, 0, 3871, 3872, 5, 23, 0, 0, 3872, 3873, 3, 646, 323, 0, 3873, 3874, 5, 70, 0, 0, 3874, 3875, 5, 308, 0, 0, 3875, 3876, 5, 331, 0, 0, 3876, 3877, 3, 646, 323, 0, 3877, 3878, 5, 464, 0, 0, 3878, 3883, 3, 462, 231, 0, 3879, 3880, 5, 462, 0, 0, 3880, 3882, 3, 462, 231, 0, 3881, 3879, 1, 0, 0, 0, 3882, 3885, 1, 0, 0, 0, 3883, 3881, 1, 0, 0, 0, 3883, 3884, 1, 0, 0, 0, 3884, 3886, 1, 0, 0, 0, 3885, 3883, 1, 0, 0, 0, 3886, 3892, 5, 465, 0, 0, 3887, 3889, 5, 464, 0, 0, 3888, 3890, 3, 90, 45, 0, 3889, 3888, 1, 0, 0, 0, 3889, 3890, 1, 0, 0, 0, 3890, 3891, 1, 0, 0, 0, 3891, 3893, 5, 465, 0, 0, 3892, 3887, 1, 0, 0, 0, 3892, 3893, 1, 0, 0, 0, 3893, 479, 1, 0, 0, 0, 3894, 3897, 5, 361, 0, 0, 3895, 3898, 3, 646, 323, 0, 3896, 3898, 5, 482, 0, 0, 3897, 3895, 1, 0, 0, 0, 3897, 3896, 1, 0, 0, 0, 3898, 3902, 1, 0, 0, 0, 3899, 3901, 3, 28, 14, 0, 3900, 3899, 1, 0, 0, 0, 3901, 3904, 1, 0, 0, 0, 3902, 3900, 1, 0, 0, 0, 3902, 3903, 1, 0, 0, 0, 3903, 481, 1, 0, 0, 0, 3904, 3902, 1, 0, 0, 0, 3905, 3906, 5, 360, 0, 0, 3906, 3907, 5, 464, 0, 0, 3907, 3912, 3, 484, 242, 0, 3908, 3909, 5, 462, 0, 0, 3909, 3911, 3, 484, 242, 0, 3910, 3908, 1, 0, 0, 0, 3911, 3914, 1, 0, 0, 0, 3912, 3910, 1, 0, 0, 0, 3912, 3913, 1, 0, 0, 0, 3913, 3915, 1, 0, 0, 0, 3914, 3912, 1, 0, 0, 0, 3915, 3916, 5, 465, 0, 0, 3916, 483, 1, 0, 0, 0, 3917, 3918, 5, 478, 0, 0, 3918, 3919, 5, 470, 0, 0, 3919, 3920, 3, 460, 230, 0, 3920, 485, 1, 0, 0, 0, 3921, 3922, 5, 424, 0, 0, 3922, 3923, 5, 425, 0, 0, 3923, 3924, 5, 306, 0, 0, 3924, 3925, 3, 646, 323, 0, 3925, 3926, 5, 464, 0, 0, 3926, 3931, 3, 462, 231, 0, 3927, 3928, 5, 462, 0, 0, 3928, 3930, 3, 462, 231, 0, 3929, 3927, 1, 0, 0, 0, 3930, 3933, 1, 0, 0, 0, 3931, 3929, 1, 0, 0, 0, 3931, 3932, 1, 0, 0, 0, 3932, 3934, 1, 0, 0, 0, 3933, 3931, 1, 0, 0, 0, 3934, 3935, 5, 465, 0, 0, 3935, 3937, 5, 466, 0, 0, 3936, 3938, 3, 488, 244, 0, 3937, 3936, 1, 0, 0, 0, 3938, 3939, 1, 0, 0, 0, 3939, 3937, 1, 0, 0, 0, 3939, 3940, 1, 0, 0, 0, 3940, 3941, 1, 0, 0, 0, 3941, 3942, 5, 467, 0, 0, 3942, 487, 1, 0, 0, 0, 3943, 3944, 5, 392, 0, 0, 3944, 3945, 5, 482, 0, 0, 3945, 3946, 5, 464, 0, 0, 3946, 3951, 3, 490, 245, 0, 3947, 3948, 5, 462, 0, 0, 3948, 3950, 3, 490, 245, 0, 3949, 3947, 1, 0, 0, 0, 3950, 3953, 1, 0, 0, 0, 3951, 3949, 1, 0, 0, 0, 3951, 3952, 1, 0, 0, 0, 3952, 3954, 1, 0, 0, 0, 3953, 3951, 1, 0, 0, 0, 3954, 3955, 5, 465, 0, 0, 3955, 3958, 7, 27, 0, 0, 3956, 3957, 5, 23, 0, 0, 3957, 3959, 3, 646, 323, 0, 3958, 3956, 1, 0, 0, 0, 3958, 3959, 1, 0, 0, 0, 3959, 3962, 1, 0, 0, 0, 3960, 3961, 5, 30, 0, 0, 3961, 3963, 3, 646, 323, 0, 3962, 3960, 1, 0, 0, 0, 3962, 3963, 1, 0, 0, 0, 3963, 3964, 1, 0, 0, 0, 3964, 3965, 5, 461, 0, 0, 3965, 489, 1, 0, 0, 0, 3966, 3967, 5, 482, 0, 0, 3967, 3968, 5, 470, 0, 0, 3968, 3969, 3, 98, 49, 0, 3969, 491, 1, 0, 0, 0, 3970, 3971, 3, 494, 247, 0, 3971, 3976, 3, 496, 248, 0, 3972, 3973, 5, 462, 0, 0, 3973, 3975, 3, 496, 248, 0, 3974, 3972, 1, 0, 0, 0, 3975, 3978, 1, 0, 0, 0, 3976, 3974, 1, 0, 0, 0, 3976, 3977, 1, 0, 0, 0, 3977, 3999, 1, 0, 0, 0, 3978, 3976, 1, 0, 0, 0, 3979, 3980, 5, 37, 0, 0, 3980, 3981, 5, 478, 0, 0, 3981, 3982, 5, 405, 0, 0, 3982, 3986, 3, 498, 249, 0, 3983, 3984, 5, 284, 0, 0, 3984, 3985, 5, 428, 0, 0, 3985, 3987, 5, 478, 0, 0, 3986, 3983, 1, 0, 0, 0, 3986, 3987, 1, 0, 0, 0, 3987, 3999, 1, 0, 0, 0, 3988, 3989, 5, 428, 0, 0, 3989, 3990, 5, 478, 0, 0, 3990, 3995, 3, 496, 248, 0, 3991, 3992, 5, 462, 0, 0, 3992, 3994, 3, 496, 248, 0, 3993, 3991, 1, 0, 0, 0, 3994, 3997, 1, 0, 0, 0, 3995, 3993, 1, 0, 0, 0, 3995, 3996, 1, 0, 0, 0, 3996, 3999, 1, 0, 0, 0, 3997, 3995, 1, 0, 0, 0, 3998, 3970, 1, 0, 0, 0, 3998, 3979, 1, 0, 0, 0, 3998, 3988, 1, 0, 0, 0, 3999, 493, 1, 0, 0, 0, 4000, 4001, 7, 28, 0, 0, 4001, 495, 1, 0, 0, 0, 4002, 4003, 5, 482, 0, 0, 4003, 4004, 5, 451, 0, 0, 4004, 4005, 3, 498, 249, 0, 4005, 497, 1, 0, 0, 0, 4006, 4011, 5, 478, 0, 0, 4007, 4011, 5, 480, 0, 0, 4008, 4011, 3, 654, 327, 0, 4009, 4011, 3, 646, 323, 0, 4010, 4006, 1, 0, 0, 0, 4010, 4007, 1, 0, 0, 0, 4010, 4008, 1, 0, 0, 0, 4010, 4009, 1, 0, 0, 0, 4011, 499, 1, 0, 0, 0, 4012, 4017, 3, 502, 251, 0, 4013, 4017, 3, 514, 257, 0, 4014, 4017, 3, 516, 258, 0, 4015, 4017, 3, 522, 261, 0, 4016, 4012, 1, 0, 0, 0, 4016, 4013, 1, 0, 0, 0, 4016, 4014, 1, 0, 0, 0, 4016, 4015, 1, 0, 0, 0, 4017, 501, 1, 0, 0, 0, 4018, 4019, 5, 64, 0, 0, 4019, 4340, 5, 367, 0, 0, 4020, 4021, 5, 64, 0, 0, 4021, 4027, 5, 368, 0, 0, 4022, 4025, 5, 284, 0, 0, 4023, 4026, 3, 646, 323, 0, 4024, 4026, 5, 482, 0, 0, 4025, 4023, 1, 0, 0, 0, 4025, 4024, 1, 0, 0, 0, 4026, 4028, 1, 0, 0, 0, 4027, 4022, 1, 0, 0, 0, 4027, 4028, 1, 0, 0, 0, 4028, 4340, 1, 0, 0, 0, 4029, 4030, 5, 64, 0, 0, 4030, 4036, 5, 369, 0, 0, 4031, 4034, 5, 284, 0, 0, 4032, 4035, 3, 646, 323, 0, 4033, 4035, 5, 482, 0, 0, 4034, 4032, 1, 0, 0, 0, 4034, 4033, 1, 0, 0, 0, 4035, 4037, 1, 0, 0, 0, 4036, 4031, 1, 0, 0, 0, 4036, 4037, 1, 0, 0, 0, 4037, 4340, 1, 0, 0, 0, 4038, 4039, 5, 64, 0, 0, 4039, 4045, 5, 370, 0, 0, 4040, 4043, 5, 284, 0, 0, 4041, 4044, 3, 646, 323, 0, 4042, 4044, 5, 482, 0, 0, 4043, 4041, 1, 0, 0, 0, 4043, 4042, 1, 0, 0, 0, 4044, 4046, 1, 0, 0, 0, 4045, 4040, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4340, 1, 0, 0, 0, 4047, 4048, 5, 64, 0, 0, 4048, 4054, 5, 371, 0, 0, 4049, 4052, 5, 284, 0, 0, 4050, 4053, 3, 646, 323, 0, 4051, 4053, 5, 482, 0, 0, 4052, 4050, 1, 0, 0, 0, 4052, 4051, 1, 0, 0, 0, 4053, 4055, 1, 0, 0, 0, 4054, 4049, 1, 0, 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, 4340, 1, 0, 0, 0, 4056, 4057, 5, 64, 0, 0, 4057, 4063, 5, 372, 0, 0, 4058, 4061, 5, 284, 0, 0, 4059, 4062, 3, 646, 323, 0, 4060, 4062, 5, 482, 0, 0, 4061, 4059, 1, 0, 0, 0, 4061, 4060, 1, 0, 0, 0, 4062, 4064, 1, 0, 0, 0, 4063, 4058, 1, 0, 0, 0, 4063, 4064, 1, 0, 0, 0, 4064, 4340, 1, 0, 0, 0, 4065, 4066, 5, 64, 0, 0, 4066, 4072, 5, 141, 0, 0, 4067, 4070, 5, 284, 0, 0, 4068, 4071, 3, 646, 323, 0, 4069, 4071, 5, 482, 0, 0, 4070, 4068, 1, 0, 0, 0, 4070, 4069, 1, 0, 0, 0, 4071, 4073, 1, 0, 0, 0, 4072, 4067, 1, 0, 0, 0, 4072, 4073, 1, 0, 0, 0, 4073, 4340, 1, 0, 0, 0, 4074, 4075, 5, 64, 0, 0, 4075, 4081, 5, 143, 0, 0, 4076, 4079, 5, 284, 0, 0, 4077, 4080, 3, 646, 323, 0, 4078, 4080, 5, 482, 0, 0, 4079, 4077, 1, 0, 0, 0, 4079, 4078, 1, 0, 0, 0, 4080, 4082, 1, 0, 0, 0, 4081, 4076, 1, 0, 0, 0, 4081, 4082, 1, 0, 0, 0, 4082, 4340, 1, 0, 0, 0, 4083, 4084, 5, 64, 0, 0, 4084, 4090, 5, 373, 0, 0, 4085, 4088, 5, 284, 0, 0, 4086, 4089, 3, 646, 323, 0, 4087, 4089, 5, 482, 0, 0, 4088, 4086, 1, 0, 0, 0, 4088, 4087, 1, 0, 0, 0, 4089, 4091, 1, 0, 0, 0, 4090, 4085, 1, 0, 0, 0, 4090, 4091, 1, 0, 0, 0, 4091, 4340, 1, 0, 0, 0, 4092, 4093, 5, 64, 0, 0, 4093, 4099, 5, 374, 0, 0, 4094, 4097, 5, 284, 0, 0, 4095, 4098, 3, 646, 323, 0, 4096, 4098, 5, 482, 0, 0, 4097, 4095, 1, 0, 0, 0, 4097, 4096, 1, 0, 0, 0, 4098, 4100, 1, 0, 0, 0, 4099, 4094, 1, 0, 0, 0, 4099, 4100, 1, 0, 0, 0, 4100, 4340, 1, 0, 0, 0, 4101, 4102, 5, 64, 0, 0, 4102, 4108, 5, 142, 0, 0, 4103, 4106, 5, 284, 0, 0, 4104, 4107, 3, 646, 323, 0, 4105, 4107, 5, 482, 0, 0, 4106, 4104, 1, 0, 0, 0, 4106, 4105, 1, 0, 0, 0, 4107, 4109, 1, 0, 0, 0, 4108, 4103, 1, 0, 0, 0, 4108, 4109, 1, 0, 0, 0, 4109, 4340, 1, 0, 0, 0, 4110, 4111, 5, 64, 0, 0, 4111, 4117, 5, 144, 0, 0, 4112, 4115, 5, 284, 0, 0, 4113, 4116, 3, 646, 323, 0, 4114, 4116, 5, 482, 0, 0, 4115, 4113, 1, 0, 0, 0, 4115, 4114, 1, 0, 0, 0, 4116, 4118, 1, 0, 0, 0, 4117, 4112, 1, 0, 0, 0, 4117, 4118, 1, 0, 0, 0, 4118, 4340, 1, 0, 0, 0, 4119, 4120, 5, 64, 0, 0, 4120, 4121, 5, 113, 0, 0, 4121, 4127, 5, 115, 0, 0, 4122, 4125, 5, 284, 0, 0, 4123, 4126, 3, 646, 323, 0, 4124, 4126, 5, 482, 0, 0, 4125, 4123, 1, 0, 0, 0, 4125, 4124, 1, 0, 0, 0, 4126, 4128, 1, 0, 0, 0, 4127, 4122, 1, 0, 0, 0, 4127, 4128, 1, 0, 0, 0, 4128, 4340, 1, 0, 0, 0, 4129, 4130, 5, 64, 0, 0, 4130, 4131, 5, 23, 0, 0, 4131, 4340, 3, 646, 323, 0, 4132, 4133, 5, 64, 0, 0, 4133, 4134, 5, 27, 0, 0, 4134, 4340, 3, 646, 323, 0, 4135, 4136, 5, 64, 0, 0, 4136, 4137, 5, 33, 0, 0, 4137, 4340, 3, 646, 323, 0, 4138, 4139, 5, 64, 0, 0, 4139, 4340, 5, 375, 0, 0, 4140, 4141, 5, 64, 0, 0, 4141, 4340, 5, 324, 0, 0, 4142, 4143, 5, 64, 0, 0, 4143, 4340, 5, 325, 0, 0, 4144, 4145, 5, 64, 0, 0, 4145, 4146, 5, 394, 0, 0, 4146, 4340, 5, 324, 0, 0, 4147, 4148, 5, 64, 0, 0, 4148, 4149, 5, 394, 0, 0, 4149, 4340, 5, 355, 0, 0, 4150, 4151, 5, 64, 0, 0, 4151, 4152, 5, 397, 0, 0, 4152, 4153, 5, 411, 0, 0, 4153, 4155, 3, 646, 323, 0, 4154, 4156, 5, 400, 0, 0, 4155, 4154, 1, 0, 0, 0, 4155, 4156, 1, 0, 0, 0, 4156, 4340, 1, 0, 0, 0, 4157, 4158, 5, 64, 0, 0, 4158, 4159, 5, 398, 0, 0, 4159, 4160, 5, 411, 0, 0, 4160, 4162, 3, 646, 323, 0, 4161, 4163, 5, 400, 0, 0, 4162, 4161, 1, 0, 0, 0, 4162, 4163, 1, 0, 0, 0, 4163, 4340, 1, 0, 0, 0, 4164, 4165, 5, 64, 0, 0, 4165, 4166, 5, 399, 0, 0, 4166, 4167, 5, 410, 0, 0, 4167, 4340, 3, 646, 323, 0, 4168, 4169, 5, 64, 0, 0, 4169, 4170, 5, 401, 0, 0, 4170, 4171, 5, 411, 0, 0, 4171, 4340, 3, 646, 323, 0, 4172, 4173, 5, 64, 0, 0, 4173, 4174, 5, 217, 0, 0, 4174, 4175, 5, 411, 0, 0, 4175, 4178, 3, 646, 323, 0, 4176, 4177, 5, 402, 0, 0, 4177, 4179, 5, 480, 0, 0, 4178, 4176, 1, 0, 0, 0, 4178, 4179, 1, 0, 0, 0, 4179, 4340, 1, 0, 0, 0, 4180, 4181, 5, 64, 0, 0, 4181, 4183, 5, 185, 0, 0, 4182, 4184, 3, 504, 252, 0, 4183, 4182, 1, 0, 0, 0, 4183, 4184, 1, 0, 0, 0, 4184, 4340, 1, 0, 0, 0, 4185, 4186, 5, 64, 0, 0, 4186, 4187, 5, 58, 0, 0, 4187, 4340, 5, 429, 0, 0, 4188, 4189, 5, 64, 0, 0, 4189, 4190, 5, 29, 0, 0, 4190, 4196, 5, 431, 0, 0, 4191, 4194, 5, 284, 0, 0, 4192, 4195, 3, 646, 323, 0, 4193, 4195, 5, 482, 0, 0, 4194, 4192, 1, 0, 0, 0, 4194, 4193, 1, 0, 0, 0, 4195, 4197, 1, 0, 0, 0, 4196, 4191, 1, 0, 0, 0, 4196, 4197, 1, 0, 0, 0, 4197, 4340, 1, 0, 0, 0, 4198, 4199, 5, 64, 0, 0, 4199, 4200, 5, 442, 0, 0, 4200, 4340, 5, 431, 0, 0, 4201, 4202, 5, 64, 0, 0, 4202, 4203, 5, 437, 0, 0, 4203, 4340, 5, 447, 0, 0, 4204, 4205, 5, 64, 0, 0, 4205, 4206, 5, 440, 0, 0, 4206, 4207, 5, 92, 0, 0, 4207, 4340, 3, 646, 323, 0, 4208, 4209, 5, 64, 0, 0, 4209, 4210, 5, 440, 0, 0, 4210, 4211, 5, 92, 0, 0, 4211, 4212, 5, 30, 0, 0, 4212, 4340, 3, 646, 323, 0, 4213, 4214, 5, 64, 0, 0, 4214, 4215, 5, 440, 0, 0, 4215, 4216, 5, 92, 0, 0, 4216, 4217, 5, 33, 0, 0, 4217, 4340, 3, 646, 323, 0, 4218, 4219, 5, 64, 0, 0, 4219, 4220, 5, 429, 0, 0, 4220, 4226, 5, 438, 0, 0, 4221, 4224, 5, 284, 0, 0, 4222, 4225, 3, 646, 323, 0, 4223, 4225, 5, 482, 0, 0, 4224, 4222, 1, 0, 0, 0, 4224, 4223, 1, 0, 0, 0, 4225, 4227, 1, 0, 0, 0, 4226, 4221, 1, 0, 0, 0, 4226, 4227, 1, 0, 0, 0, 4227, 4340, 1, 0, 0, 0, 4228, 4229, 5, 64, 0, 0, 4229, 4230, 5, 308, 0, 0, 4230, 4236, 5, 332, 0, 0, 4231, 4234, 5, 284, 0, 0, 4232, 4235, 3, 646, 323, 0, 4233, 4235, 5, 482, 0, 0, 4234, 4232, 1, 0, 0, 0, 4234, 4233, 1, 0, 0, 0, 4235, 4237, 1, 0, 0, 0, 4236, 4231, 1, 0, 0, 0, 4236, 4237, 1, 0, 0, 0, 4237, 4340, 1, 0, 0, 0, 4238, 4239, 5, 64, 0, 0, 4239, 4240, 5, 308, 0, 0, 4240, 4246, 5, 307, 0, 0, 4241, 4244, 5, 284, 0, 0, 4242, 4245, 3, 646, 323, 0, 4243, 4245, 5, 482, 0, 0, 4244, 4242, 1, 0, 0, 0, 4244, 4243, 1, 0, 0, 0, 4245, 4247, 1, 0, 0, 0, 4246, 4241, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4340, 1, 0, 0, 0, 4248, 4249, 5, 64, 0, 0, 4249, 4250, 5, 26, 0, 0, 4250, 4256, 5, 368, 0, 0, 4251, 4254, 5, 284, 0, 0, 4252, 4255, 3, 646, 323, 0, 4253, 4255, 5, 482, 0, 0, 4254, 4252, 1, 0, 0, 0, 4254, 4253, 1, 0, 0, 0, 4255, 4257, 1, 0, 0, 0, 4256, 4251, 1, 0, 0, 0, 4256, 4257, 1, 0, 0, 0, 4257, 4340, 1, 0, 0, 0, 4258, 4259, 5, 64, 0, 0, 4259, 4340, 5, 361, 0, 0, 4260, 4261, 5, 64, 0, 0, 4261, 4262, 5, 361, 0, 0, 4262, 4265, 5, 362, 0, 0, 4263, 4266, 3, 646, 323, 0, 4264, 4266, 5, 482, 0, 0, 4265, 4263, 1, 0, 0, 0, 4265, 4264, 1, 0, 0, 0, 4265, 4266, 1, 0, 0, 0, 4266, 4340, 1, 0, 0, 0, 4267, 4268, 5, 64, 0, 0, 4268, 4269, 5, 361, 0, 0, 4269, 4340, 5, 363, 0, 0, 4270, 4271, 5, 64, 0, 0, 4271, 4272, 5, 206, 0, 0, 4272, 4275, 5, 207, 0, 0, 4273, 4274, 5, 413, 0, 0, 4274, 4276, 3, 506, 253, 0, 4275, 4273, 1, 0, 0, 0, 4275, 4276, 1, 0, 0, 0, 4276, 4340, 1, 0, 0, 0, 4277, 4278, 5, 64, 0, 0, 4278, 4281, 5, 403, 0, 0, 4279, 4280, 5, 402, 0, 0, 4280, 4282, 5, 480, 0, 0, 4281, 4279, 1, 0, 0, 0, 4281, 4282, 1, 0, 0, 0, 4282, 4288, 1, 0, 0, 0, 4283, 4286, 5, 284, 0, 0, 4284, 4287, 3, 646, 323, 0, 4285, 4287, 5, 482, 0, 0, 4286, 4284, 1, 0, 0, 0, 4286, 4285, 1, 0, 0, 0, 4287, 4289, 1, 0, 0, 0, 4288, 4283, 1, 0, 0, 0, 4288, 4289, 1, 0, 0, 0, 4289, 4291, 1, 0, 0, 0, 4290, 4292, 5, 84, 0, 0, 4291, 4290, 1, 0, 0, 0, 4291, 4292, 1, 0, 0, 0, 4292, 4340, 1, 0, 0, 0, 4293, 4294, 5, 64, 0, 0, 4294, 4295, 5, 424, 0, 0, 4295, 4296, 5, 425, 0, 0, 4296, 4302, 5, 307, 0, 0, 4297, 4300, 5, 284, 0, 0, 4298, 4301, 3, 646, 323, 0, 4299, 4301, 5, 482, 0, 0, 4300, 4298, 1, 0, 0, 0, 4300, 4299, 1, 0, 0, 0, 4301, 4303, 1, 0, 0, 0, 4302, 4297, 1, 0, 0, 0, 4302, 4303, 1, 0, 0, 0, 4303, 4340, 1, 0, 0, 0, 4304, 4305, 5, 64, 0, 0, 4305, 4306, 5, 424, 0, 0, 4306, 4307, 5, 425, 0, 0, 4307, 4313, 5, 332, 0, 0, 4308, 4311, 5, 284, 0, 0, 4309, 4312, 3, 646, 323, 0, 4310, 4312, 5, 482, 0, 0, 4311, 4309, 1, 0, 0, 0, 4311, 4310, 1, 0, 0, 0, 4312, 4314, 1, 0, 0, 0, 4313, 4308, 1, 0, 0, 0, 4313, 4314, 1, 0, 0, 0, 4314, 4340, 1, 0, 0, 0, 4315, 4316, 5, 64, 0, 0, 4316, 4317, 5, 424, 0, 0, 4317, 4323, 5, 118, 0, 0, 4318, 4321, 5, 284, 0, 0, 4319, 4322, 3, 646, 323, 0, 4320, 4322, 5, 482, 0, 0, 4321, 4319, 1, 0, 0, 0, 4321, 4320, 1, 0, 0, 0, 4322, 4324, 1, 0, 0, 0, 4323, 4318, 1, 0, 0, 0, 4323, 4324, 1, 0, 0, 0, 4324, 4340, 1, 0, 0, 0, 4325, 4326, 5, 64, 0, 0, 4326, 4340, 5, 427, 0, 0, 4327, 4328, 5, 64, 0, 0, 4328, 4340, 5, 378, 0, 0, 4329, 4330, 5, 64, 0, 0, 4330, 4331, 5, 343, 0, 0, 4331, 4337, 5, 375, 0, 0, 4332, 4335, 5, 284, 0, 0, 4333, 4336, 3, 646, 323, 0, 4334, 4336, 5, 482, 0, 0, 4335, 4333, 1, 0, 0, 0, 4335, 4334, 1, 0, 0, 0, 4336, 4338, 1, 0, 0, 0, 4337, 4332, 1, 0, 0, 0, 4337, 4338, 1, 0, 0, 0, 4338, 4340, 1, 0, 0, 0, 4339, 4018, 1, 0, 0, 0, 4339, 4020, 1, 0, 0, 0, 4339, 4029, 1, 0, 0, 0, 4339, 4038, 1, 0, 0, 0, 4339, 4047, 1, 0, 0, 0, 4339, 4056, 1, 0, 0, 0, 4339, 4065, 1, 0, 0, 0, 4339, 4074, 1, 0, 0, 0, 4339, 4083, 1, 0, 0, 0, 4339, 4092, 1, 0, 0, 0, 4339, 4101, 1, 0, 0, 0, 4339, 4110, 1, 0, 0, 0, 4339, 4119, 1, 0, 0, 0, 4339, 4129, 1, 0, 0, 0, 4339, 4132, 1, 0, 0, 0, 4339, 4135, 1, 0, 0, 0, 4339, 4138, 1, 0, 0, 0, 4339, 4140, 1, 0, 0, 0, 4339, 4142, 1, 0, 0, 0, 4339, 4144, 1, 0, 0, 0, 4339, 4147, 1, 0, 0, 0, 4339, 4150, 1, 0, 0, 0, 4339, 4157, 1, 0, 0, 0, 4339, 4164, 1, 0, 0, 0, 4339, 4168, 1, 0, 0, 0, 4339, 4172, 1, 0, 0, 0, 4339, 4180, 1, 0, 0, 0, 4339, 4185, 1, 0, 0, 0, 4339, 4188, 1, 0, 0, 0, 4339, 4198, 1, 0, 0, 0, 4339, 4201, 1, 0, 0, 0, 4339, 4204, 1, 0, 0, 0, 4339, 4208, 1, 0, 0, 0, 4339, 4213, 1, 0, 0, 0, 4339, 4218, 1, 0, 0, 0, 4339, 4228, 1, 0, 0, 0, 4339, 4238, 1, 0, 0, 0, 4339, 4248, 1, 0, 0, 0, 4339, 4258, 1, 0, 0, 0, 4339, 4260, 1, 0, 0, 0, 4339, 4267, 1, 0, 0, 0, 4339, 4270, 1, 0, 0, 0, 4339, 4277, 1, 0, 0, 0, 4339, 4293, 1, 0, 0, 0, 4339, 4304, 1, 0, 0, 0, 4339, 4315, 1, 0, 0, 0, 4339, 4325, 1, 0, 0, 0, 4339, 4327, 1, 0, 0, 0, 4339, 4329, 1, 0, 0, 0, 4340, 503, 1, 0, 0, 0, 4341, 4342, 5, 71, 0, 0, 4342, 4347, 3, 508, 254, 0, 4343, 4344, 5, 280, 0, 0, 4344, 4346, 3, 508, 254, 0, 4345, 4343, 1, 0, 0, 0, 4346, 4349, 1, 0, 0, 0, 4347, 4345, 1, 0, 0, 0, 4347, 4348, 1, 0, 0, 0, 4348, 4355, 1, 0, 0, 0, 4349, 4347, 1, 0, 0, 0, 4350, 4353, 5, 284, 0, 0, 4351, 4354, 3, 646, 323, 0, 4352, 4354, 5, 482, 0, 0, 4353, 4351, 1, 0, 0, 0, 4353, 4352, 1, 0, 0, 0, 4354, 4356, 1, 0, 0, 0, 4355, 4350, 1, 0, 0, 0, 4355, 4356, 1, 0, 0, 0, 4356, 4363, 1, 0, 0, 0, 4357, 4360, 5, 284, 0, 0, 4358, 4361, 3, 646, 323, 0, 4359, 4361, 5, 482, 0, 0, 4360, 4358, 1, 0, 0, 0, 4360, 4359, 1, 0, 0, 0, 4361, 4363, 1, 0, 0, 0, 4362, 4341, 1, 0, 0, 0, 4362, 4357, 1, 0, 0, 0, 4363, 505, 1, 0, 0, 0, 4364, 4365, 7, 29, 0, 0, 4365, 507, 1, 0, 0, 0, 4366, 4367, 5, 422, 0, 0, 4367, 4368, 7, 30, 0, 0, 4368, 4373, 5, 478, 0, 0, 4369, 4370, 5, 482, 0, 0, 4370, 4371, 7, 30, 0, 0, 4371, 4373, 5, 478, 0, 0, 4372, 4366, 1, 0, 0, 0, 4372, 4369, 1, 0, 0, 0, 4373, 509, 1, 0, 0, 0, 4374, 4375, 5, 478, 0, 0, 4375, 4376, 5, 451, 0, 0, 4376, 4377, 3, 512, 256, 0, 4377, 511, 1, 0, 0, 0, 4378, 4383, 5, 478, 0, 0, 4379, 4383, 5, 480, 0, 0, 4380, 4383, 3, 654, 327, 0, 4381, 4383, 5, 283, 0, 0, 4382, 4378, 1, 0, 0, 0, 4382, 4379, 1, 0, 0, 0, 4382, 4380, 1, 0, 0, 0, 4382, 4381, 1, 0, 0, 0, 4383, 513, 1, 0, 0, 0, 4384, 4385, 5, 65, 0, 0, 4385, 4386, 5, 23, 0, 0, 4386, 4499, 3, 646, 323, 0, 4387, 4388, 5, 65, 0, 0, 4388, 4389, 5, 27, 0, 0, 4389, 4499, 3, 646, 323, 0, 4390, 4391, 5, 65, 0, 0, 4391, 4392, 5, 30, 0, 0, 4392, 4499, 3, 646, 323, 0, 4393, 4394, 5, 65, 0, 0, 4394, 4395, 5, 31, 0, 0, 4395, 4499, 3, 646, 323, 0, 4396, 4397, 5, 65, 0, 0, 4397, 4398, 5, 32, 0, 0, 4398, 4499, 3, 646, 323, 0, 4399, 4400, 5, 65, 0, 0, 4400, 4401, 5, 33, 0, 0, 4401, 4499, 3, 646, 323, 0, 4402, 4403, 5, 65, 0, 0, 4403, 4404, 5, 34, 0, 0, 4404, 4499, 3, 646, 323, 0, 4405, 4406, 5, 65, 0, 0, 4406, 4407, 5, 35, 0, 0, 4407, 4499, 3, 646, 323, 0, 4408, 4409, 5, 65, 0, 0, 4409, 4410, 5, 28, 0, 0, 4410, 4499, 3, 646, 323, 0, 4411, 4412, 5, 65, 0, 0, 4412, 4413, 5, 37, 0, 0, 4413, 4499, 3, 646, 323, 0, 4414, 4415, 5, 65, 0, 0, 4415, 4416, 5, 113, 0, 0, 4416, 4417, 5, 114, 0, 0, 4417, 4499, 3, 646, 323, 0, 4418, 4419, 5, 65, 0, 0, 4419, 4420, 5, 29, 0, 0, 4420, 4423, 5, 482, 0, 0, 4421, 4422, 5, 137, 0, 0, 4422, 4424, 5, 84, 0, 0, 4423, 4421, 1, 0, 0, 0, 4423, 4424, 1, 0, 0, 0, 4424, 4499, 1, 0, 0, 0, 4425, 4426, 5, 65, 0, 0, 4426, 4427, 5, 29, 0, 0, 4427, 4428, 5, 430, 0, 0, 4428, 4499, 3, 646, 323, 0, 4429, 4430, 5, 65, 0, 0, 4430, 4431, 5, 442, 0, 0, 4431, 4432, 5, 430, 0, 0, 4432, 4499, 5, 478, 0, 0, 4433, 4434, 5, 65, 0, 0, 4434, 4435, 5, 437, 0, 0, 4435, 4436, 5, 442, 0, 0, 4436, 4499, 5, 478, 0, 0, 4437, 4438, 5, 65, 0, 0, 4438, 4439, 5, 308, 0, 0, 4439, 4440, 5, 331, 0, 0, 4440, 4499, 3, 646, 323, 0, 4441, 4442, 5, 65, 0, 0, 4442, 4443, 5, 308, 0, 0, 4443, 4444, 5, 306, 0, 0, 4444, 4499, 3, 646, 323, 0, 4445, 4446, 5, 65, 0, 0, 4446, 4447, 5, 26, 0, 0, 4447, 4448, 5, 23, 0, 0, 4448, 4499, 3, 646, 323, 0, 4449, 4450, 5, 65, 0, 0, 4450, 4453, 5, 361, 0, 0, 4451, 4454, 3, 646, 323, 0, 4452, 4454, 5, 482, 0, 0, 4453, 4451, 1, 0, 0, 0, 4453, 4452, 1, 0, 0, 0, 4453, 4454, 1, 0, 0, 0, 4454, 4499, 1, 0, 0, 0, 4455, 4456, 5, 65, 0, 0, 4456, 4457, 5, 209, 0, 0, 4457, 4458, 5, 92, 0, 0, 4458, 4459, 7, 1, 0, 0, 4459, 4462, 3, 646, 323, 0, 4460, 4461, 5, 184, 0, 0, 4461, 4463, 5, 482, 0, 0, 4462, 4460, 1, 0, 0, 0, 4462, 4463, 1, 0, 0, 0, 4463, 4499, 1, 0, 0, 0, 4464, 4465, 5, 65, 0, 0, 4465, 4466, 5, 394, 0, 0, 4466, 4467, 5, 463, 0, 0, 4467, 4499, 3, 520, 260, 0, 4468, 4469, 5, 65, 0, 0, 4469, 4470, 5, 424, 0, 0, 4470, 4471, 5, 425, 0, 0, 4471, 4472, 5, 306, 0, 0, 4472, 4499, 3, 646, 323, 0, 4473, 4474, 5, 65, 0, 0, 4474, 4475, 5, 343, 0, 0, 4475, 4476, 5, 342, 0, 0, 4476, 4499, 3, 646, 323, 0, 4477, 4478, 5, 65, 0, 0, 4478, 4499, 5, 427, 0, 0, 4479, 4480, 5, 65, 0, 0, 4480, 4481, 5, 377, 0, 0, 4481, 4482, 5, 70, 0, 0, 4482, 4483, 5, 33, 0, 0, 4483, 4484, 3, 646, 323, 0, 4484, 4485, 5, 184, 0, 0, 4485, 4486, 3, 648, 324, 0, 4486, 4499, 1, 0, 0, 0, 4487, 4488, 5, 65, 0, 0, 4488, 4489, 5, 377, 0, 0, 4489, 4490, 5, 70, 0, 0, 4490, 4491, 5, 34, 0, 0, 4491, 4492, 3, 646, 323, 0, 4492, 4493, 5, 184, 0, 0, 4493, 4494, 3, 648, 324, 0, 4494, 4499, 1, 0, 0, 0, 4495, 4496, 5, 65, 0, 0, 4496, 4497, 5, 377, 0, 0, 4497, 4499, 3, 648, 324, 0, 4498, 4384, 1, 0, 0, 0, 4498, 4387, 1, 0, 0, 0, 4498, 4390, 1, 0, 0, 0, 4498, 4393, 1, 0, 0, 0, 4498, 4396, 1, 0, 0, 0, 4498, 4399, 1, 0, 0, 0, 4498, 4402, 1, 0, 0, 0, 4498, 4405, 1, 0, 0, 0, 4498, 4408, 1, 0, 0, 0, 4498, 4411, 1, 0, 0, 0, 4498, 4414, 1, 0, 0, 0, 4498, 4418, 1, 0, 0, 0, 4498, 4425, 1, 0, 0, 0, 4498, 4429, 1, 0, 0, 0, 4498, 4433, 1, 0, 0, 0, 4498, 4437, 1, 0, 0, 0, 4498, 4441, 1, 0, 0, 0, 4498, 4445, 1, 0, 0, 0, 4498, 4449, 1, 0, 0, 0, 4498, 4455, 1, 0, 0, 0, 4498, 4464, 1, 0, 0, 0, 4498, 4468, 1, 0, 0, 0, 4498, 4473, 1, 0, 0, 0, 4498, 4477, 1, 0, 0, 0, 4498, 4479, 1, 0, 0, 0, 4498, 4487, 1, 0, 0, 0, 4498, 4495, 1, 0, 0, 0, 4499, 515, 1, 0, 0, 0, 4500, 4502, 5, 69, 0, 0, 4501, 4503, 7, 31, 0, 0, 4502, 4501, 1, 0, 0, 0, 4502, 4503, 1, 0, 0, 0, 4503, 4504, 1, 0, 0, 0, 4504, 4505, 3, 528, 264, 0, 4505, 4506, 5, 70, 0, 0, 4506, 4507, 5, 394, 0, 0, 4507, 4508, 5, 463, 0, 0, 4508, 4513, 3, 520, 260, 0, 4509, 4511, 5, 75, 0, 0, 4510, 4509, 1, 0, 0, 0, 4510, 4511, 1, 0, 0, 0, 4511, 4512, 1, 0, 0, 0, 4512, 4514, 5, 482, 0, 0, 4513, 4510, 1, 0, 0, 0, 4513, 4514, 1, 0, 0, 0, 4514, 4518, 1, 0, 0, 0, 4515, 4517, 3, 518, 259, 0, 4516, 4515, 1, 0, 0, 0, 4517, 4520, 1, 0, 0, 0, 4518, 4516, 1, 0, 0, 0, 4518, 4519, 1, 0, 0, 0, 4519, 4523, 1, 0, 0, 0, 4520, 4518, 1, 0, 0, 0, 4521, 4522, 5, 71, 0, 0, 4522, 4524, 3, 608, 304, 0, 4523, 4521, 1, 0, 0, 0, 4523, 4524, 1, 0, 0, 0, 4524, 4531, 1, 0, 0, 0, 4525, 4526, 5, 8, 0, 0, 4526, 4529, 3, 556, 278, 0, 4527, 4528, 5, 72, 0, 0, 4528, 4530, 3, 608, 304, 0, 4529, 4527, 1, 0, 0, 0, 4529, 4530, 1, 0, 0, 0, 4530, 4532, 1, 0, 0, 0, 4531, 4525, 1, 0, 0, 0, 4531, 4532, 1, 0, 0, 0, 4532, 4535, 1, 0, 0, 0, 4533, 4534, 5, 9, 0, 0, 4534, 4536, 3, 552, 276, 0, 4535, 4533, 1, 0, 0, 0, 4535, 4536, 1, 0, 0, 0, 4536, 4539, 1, 0, 0, 0, 4537, 4538, 5, 74, 0, 0, 4538, 4540, 5, 480, 0, 0, 4539, 4537, 1, 0, 0, 0, 4539, 4540, 1, 0, 0, 0, 4540, 4543, 1, 0, 0, 0, 4541, 4542, 5, 73, 0, 0, 4542, 4544, 5, 480, 0, 0, 4543, 4541, 1, 0, 0, 0, 4543, 4544, 1, 0, 0, 0, 4544, 517, 1, 0, 0, 0, 4545, 4547, 3, 542, 271, 0, 4546, 4545, 1, 0, 0, 0, 4546, 4547, 1, 0, 0, 0, 4547, 4548, 1, 0, 0, 0, 4548, 4549, 5, 85, 0, 0, 4549, 4550, 5, 394, 0, 0, 4550, 4551, 5, 463, 0, 0, 4551, 4556, 3, 520, 260, 0, 4552, 4554, 5, 75, 0, 0, 4553, 4552, 1, 0, 0, 0, 4553, 4554, 1, 0, 0, 0, 4554, 4555, 1, 0, 0, 0, 4555, 4557, 5, 482, 0, 0, 4556, 4553, 1, 0, 0, 0, 4556, 4557, 1, 0, 0, 0, 4557, 4560, 1, 0, 0, 0, 4558, 4559, 5, 92, 0, 0, 4559, 4561, 3, 608, 304, 0, 4560, 4558, 1, 0, 0, 0, 4560, 4561, 1, 0, 0, 0, 4561, 519, 1, 0, 0, 0, 4562, 4563, 7, 32, 0, 0, 4563, 521, 1, 0, 0, 0, 4564, 4572, 3, 524, 262, 0, 4565, 4567, 5, 123, 0, 0, 4566, 4568, 5, 84, 0, 0, 4567, 4566, 1, 0, 0, 0, 4567, 4568, 1, 0, 0, 0, 4568, 4569, 1, 0, 0, 0, 4569, 4571, 3, 524, 262, 0, 4570, 4565, 1, 0, 0, 0, 4571, 4574, 1, 0, 0, 0, 4572, 4570, 1, 0, 0, 0, 4572, 4573, 1, 0, 0, 0, 4573, 523, 1, 0, 0, 0, 4574, 4572, 1, 0, 0, 0, 4575, 4577, 3, 526, 263, 0, 4576, 4578, 3, 534, 267, 0, 4577, 4576, 1, 0, 0, 0, 4577, 4578, 1, 0, 0, 0, 4578, 4580, 1, 0, 0, 0, 4579, 4581, 3, 544, 272, 0, 4580, 4579, 1, 0, 0, 0, 4580, 4581, 1, 0, 0, 0, 4581, 4583, 1, 0, 0, 0, 4582, 4584, 3, 546, 273, 0, 4583, 4582, 1, 0, 0, 0, 4583, 4584, 1, 0, 0, 0, 4584, 4586, 1, 0, 0, 0, 4585, 4587, 3, 548, 274, 0, 4586, 4585, 1, 0, 0, 0, 4586, 4587, 1, 0, 0, 0, 4587, 4589, 1, 0, 0, 0, 4588, 4590, 3, 550, 275, 0, 4589, 4588, 1, 0, 0, 0, 4589, 4590, 1, 0, 0, 0, 4590, 4592, 1, 0, 0, 0, 4591, 4593, 3, 558, 279, 0, 4592, 4591, 1, 0, 0, 0, 4592, 4593, 1, 0, 0, 0, 4593, 4612, 1, 0, 0, 0, 4594, 4596, 3, 534, 267, 0, 4595, 4597, 3, 544, 272, 0, 4596, 4595, 1, 0, 0, 0, 4596, 4597, 1, 0, 0, 0, 4597, 4599, 1, 0, 0, 0, 4598, 4600, 3, 546, 273, 0, 4599, 4598, 1, 0, 0, 0, 4599, 4600, 1, 0, 0, 0, 4600, 4602, 1, 0, 0, 0, 4601, 4603, 3, 548, 274, 0, 4602, 4601, 1, 0, 0, 0, 4602, 4603, 1, 0, 0, 0, 4603, 4604, 1, 0, 0, 0, 4604, 4606, 3, 526, 263, 0, 4605, 4607, 3, 550, 275, 0, 4606, 4605, 1, 0, 0, 0, 4606, 4607, 1, 0, 0, 0, 4607, 4609, 1, 0, 0, 0, 4608, 4610, 3, 558, 279, 0, 4609, 4608, 1, 0, 0, 0, 4609, 4610, 1, 0, 0, 0, 4610, 4612, 1, 0, 0, 0, 4611, 4575, 1, 0, 0, 0, 4611, 4594, 1, 0, 0, 0, 4612, 525, 1, 0, 0, 0, 4613, 4615, 5, 69, 0, 0, 4614, 4616, 7, 31, 0, 0, 4615, 4614, 1, 0, 0, 0, 4615, 4616, 1, 0, 0, 0, 4616, 4617, 1, 0, 0, 0, 4617, 4618, 3, 528, 264, 0, 4618, 527, 1, 0, 0, 0, 4619, 4629, 5, 456, 0, 0, 4620, 4625, 3, 530, 265, 0, 4621, 4622, 5, 462, 0, 0, 4622, 4624, 3, 530, 265, 0, 4623, 4621, 1, 0, 0, 0, 4624, 4627, 1, 0, 0, 0, 4625, 4623, 1, 0, 0, 0, 4625, 4626, 1, 0, 0, 0, 4626, 4629, 1, 0, 0, 0, 4627, 4625, 1, 0, 0, 0, 4628, 4619, 1, 0, 0, 0, 4628, 4620, 1, 0, 0, 0, 4629, 529, 1, 0, 0, 0, 4630, 4633, 3, 608, 304, 0, 4631, 4632, 5, 75, 0, 0, 4632, 4634, 3, 532, 266, 0, 4633, 4631, 1, 0, 0, 0, 4633, 4634, 1, 0, 0, 0, 4634, 4641, 1, 0, 0, 0, 4635, 4638, 3, 634, 317, 0, 4636, 4637, 5, 75, 0, 0, 4637, 4639, 3, 532, 266, 0, 4638, 4636, 1, 0, 0, 0, 4638, 4639, 1, 0, 0, 0, 4639, 4641, 1, 0, 0, 0, 4640, 4630, 1, 0, 0, 0, 4640, 4635, 1, 0, 0, 0, 4641, 531, 1, 0, 0, 0, 4642, 4645, 5, 482, 0, 0, 4643, 4645, 3, 668, 334, 0, 4644, 4642, 1, 0, 0, 0, 4644, 4643, 1, 0, 0, 0, 4645, 533, 1, 0, 0, 0, 4646, 4647, 5, 70, 0, 0, 4647, 4651, 3, 536, 268, 0, 4648, 4650, 3, 538, 269, 0, 4649, 4648, 1, 0, 0, 0, 4650, 4653, 1, 0, 0, 0, 4651, 4649, 1, 0, 0, 0, 4651, 4652, 1, 0, 0, 0, 4652, 535, 1, 0, 0, 0, 4653, 4651, 1, 0, 0, 0, 4654, 4659, 3, 646, 323, 0, 4655, 4657, 5, 75, 0, 0, 4656, 4655, 1, 0, 0, 0, 4656, 4657, 1, 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4660, 5, 482, 0, 0, 4659, 4656, 1, 0, 0, 0, 4659, 4660, 1, 0, 0, 0, 4660, 4671, 1, 0, 0, 0, 4661, 4662, 5, 464, 0, 0, 4662, 4663, 3, 522, 261, 0, 4663, 4668, 5, 465, 0, 0, 4664, 4666, 5, 75, 0, 0, 4665, 4664, 1, 0, 0, 0, 4665, 4666, 1, 0, 0, 0, 4666, 4667, 1, 0, 0, 0, 4667, 4669, 5, 482, 0, 0, 4668, 4665, 1, 0, 0, 0, 4668, 4669, 1, 0, 0, 0, 4669, 4671, 1, 0, 0, 0, 4670, 4654, 1, 0, 0, 0, 4670, 4661, 1, 0, 0, 0, 4671, 537, 1, 0, 0, 0, 4672, 4674, 3, 542, 271, 0, 4673, 4672, 1, 0, 0, 0, 4673, 4674, 1, 0, 0, 0, 4674, 4675, 1, 0, 0, 0, 4675, 4676, 5, 85, 0, 0, 4676, 4679, 3, 536, 268, 0, 4677, 4678, 5, 92, 0, 0, 4678, 4680, 3, 608, 304, 0, 4679, 4677, 1, 0, 0, 0, 4679, 4680, 1, 0, 0, 0, 4680, 4693, 1, 0, 0, 0, 4681, 4683, 3, 542, 271, 0, 4682, 4681, 1, 0, 0, 0, 4682, 4683, 1, 0, 0, 0, 4683, 4684, 1, 0, 0, 0, 4684, 4685, 5, 85, 0, 0, 4685, 4690, 3, 540, 270, 0, 4686, 4688, 5, 75, 0, 0, 4687, 4686, 1, 0, 0, 0, 4687, 4688, 1, 0, 0, 0, 4688, 4689, 1, 0, 0, 0, 4689, 4691, 5, 482, 0, 0, 4690, 4687, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4693, 1, 0, 0, 0, 4692, 4673, 1, 0, 0, 0, 4692, 4682, 1, 0, 0, 0, 4693, 539, 1, 0, 0, 0, 4694, 4695, 5, 482, 0, 0, 4695, 4696, 5, 457, 0, 0, 4696, 4697, 3, 646, 323, 0, 4697, 4698, 5, 457, 0, 0, 4698, 4699, 3, 646, 323, 0, 4699, 4705, 1, 0, 0, 0, 4700, 4701, 3, 646, 323, 0, 4701, 4702, 5, 457, 0, 0, 4702, 4703, 3, 646, 323, 0, 4703, 4705, 1, 0, 0, 0, 4704, 4694, 1, 0, 0, 0, 4704, 4700, 1, 0, 0, 0, 4705, 541, 1, 0, 0, 0, 4706, 4708, 5, 86, 0, 0, 4707, 4709, 5, 89, 0, 0, 4708, 4707, 1, 0, 0, 0, 4708, 4709, 1, 0, 0, 0, 4709, 4721, 1, 0, 0, 0, 4710, 4712, 5, 87, 0, 0, 4711, 4713, 5, 89, 0, 0, 4712, 4711, 1, 0, 0, 0, 4712, 4713, 1, 0, 0, 0, 4713, 4721, 1, 0, 0, 0, 4714, 4721, 5, 88, 0, 0, 4715, 4717, 5, 90, 0, 0, 4716, 4718, 5, 89, 0, 0, 4717, 4716, 1, 0, 0, 0, 4717, 4718, 1, 0, 0, 0, 4718, 4721, 1, 0, 0, 0, 4719, 4721, 5, 91, 0, 0, 4720, 4706, 1, 0, 0, 0, 4720, 4710, 1, 0, 0, 0, 4720, 4714, 1, 0, 0, 0, 4720, 4715, 1, 0, 0, 0, 4720, 4719, 1, 0, 0, 0, 4721, 543, 1, 0, 0, 0, 4722, 4723, 5, 71, 0, 0, 4723, 4724, 3, 608, 304, 0, 4724, 545, 1, 0, 0, 0, 4725, 4726, 5, 8, 0, 0, 4726, 4727, 3, 644, 322, 0, 4727, 547, 1, 0, 0, 0, 4728, 4729, 5, 72, 0, 0, 4729, 4730, 3, 608, 304, 0, 4730, 549, 1, 0, 0, 0, 4731, 4732, 5, 9, 0, 0, 4732, 4733, 3, 552, 276, 0, 4733, 551, 1, 0, 0, 0, 4734, 4739, 3, 554, 277, 0, 4735, 4736, 5, 462, 0, 0, 4736, 4738, 3, 554, 277, 0, 4737, 4735, 1, 0, 0, 0, 4738, 4741, 1, 0, 0, 0, 4739, 4737, 1, 0, 0, 0, 4739, 4740, 1, 0, 0, 0, 4740, 553, 1, 0, 0, 0, 4741, 4739, 1, 0, 0, 0, 4742, 4744, 3, 608, 304, 0, 4743, 4745, 7, 6, 0, 0, 4744, 4743, 1, 0, 0, 0, 4744, 4745, 1, 0, 0, 0, 4745, 555, 1, 0, 0, 0, 4746, 4751, 3, 608, 304, 0, 4747, 4748, 5, 462, 0, 0, 4748, 4750, 3, 608, 304, 0, 4749, 4747, 1, 0, 0, 0, 4750, 4753, 1, 0, 0, 0, 4751, 4749, 1, 0, 0, 0, 4751, 4752, 1, 0, 0, 0, 4752, 557, 1, 0, 0, 0, 4753, 4751, 1, 0, 0, 0, 4754, 4755, 5, 74, 0, 0, 4755, 4758, 5, 480, 0, 0, 4756, 4757, 5, 73, 0, 0, 4757, 4759, 5, 480, 0, 0, 4758, 4756, 1, 0, 0, 0, 4758, 4759, 1, 0, 0, 0, 4759, 4767, 1, 0, 0, 0, 4760, 4761, 5, 73, 0, 0, 4761, 4764, 5, 480, 0, 0, 4762, 4763, 5, 74, 0, 0, 4763, 4765, 5, 480, 0, 0, 4764, 4762, 1, 0, 0, 0, 4764, 4765, 1, 0, 0, 0, 4765, 4767, 1, 0, 0, 0, 4766, 4754, 1, 0, 0, 0, 4766, 4760, 1, 0, 0, 0, 4767, 559, 1, 0, 0, 0, 4768, 4785, 3, 564, 282, 0, 4769, 4785, 3, 566, 283, 0, 4770, 4785, 3, 568, 284, 0, 4771, 4785, 3, 570, 285, 0, 4772, 4785, 3, 572, 286, 0, 4773, 4785, 3, 574, 287, 0, 4774, 4785, 3, 576, 288, 0, 4775, 4785, 3, 578, 289, 0, 4776, 4785, 3, 562, 281, 0, 4777, 4785, 3, 584, 292, 0, 4778, 4785, 3, 590, 295, 0, 4779, 4785, 3, 592, 296, 0, 4780, 4785, 3, 606, 303, 0, 4781, 4785, 3, 594, 297, 0, 4782, 4785, 3, 598, 299, 0, 4783, 4785, 3, 604, 302, 0, 4784, 4768, 1, 0, 0, 0, 4784, 4769, 1, 0, 0, 0, 4784, 4770, 1, 0, 0, 0, 4784, 4771, 1, 0, 0, 0, 4784, 4772, 1, 0, 0, 0, 4784, 4773, 1, 0, 0, 0, 4784, 4774, 1, 0, 0, 0, 4784, 4775, 1, 0, 0, 0, 4784, 4776, 1, 0, 0, 0, 4784, 4777, 1, 0, 0, 0, 4784, 4778, 1, 0, 0, 0, 4784, 4779, 1, 0, 0, 0, 4784, 4780, 1, 0, 0, 0, 4784, 4781, 1, 0, 0, 0, 4784, 4782, 1, 0, 0, 0, 4784, 4783, 1, 0, 0, 0, 4785, 561, 1, 0, 0, 0, 4786, 4787, 5, 156, 0, 0, 4787, 4788, 5, 478, 0, 0, 4788, 563, 1, 0, 0, 0, 4789, 4790, 5, 55, 0, 0, 4790, 4791, 5, 410, 0, 0, 4791, 4792, 5, 58, 0, 0, 4792, 4795, 5, 478, 0, 0, 4793, 4794, 5, 60, 0, 0, 4794, 4796, 5, 478, 0, 0, 4795, 4793, 1, 0, 0, 0, 4795, 4796, 1, 0, 0, 0, 4796, 4797, 1, 0, 0, 0, 4797, 4798, 5, 61, 0, 0, 4798, 4813, 5, 478, 0, 0, 4799, 4800, 5, 55, 0, 0, 4800, 4801, 5, 57, 0, 0, 4801, 4813, 5, 478, 0, 0, 4802, 4803, 5, 55, 0, 0, 4803, 4804, 5, 59, 0, 0, 4804, 4805, 5, 62, 0, 0, 4805, 4806, 5, 478, 0, 0, 4806, 4807, 5, 63, 0, 0, 4807, 4810, 5, 480, 0, 0, 4808, 4809, 5, 61, 0, 0, 4809, 4811, 5, 478, 0, 0, 4810, 4808, 1, 0, 0, 0, 4810, 4811, 1, 0, 0, 0, 4811, 4813, 1, 0, 0, 0, 4812, 4789, 1, 0, 0, 0, 4812, 4799, 1, 0, 0, 0, 4812, 4802, 1, 0, 0, 0, 4813, 565, 1, 0, 0, 0, 4814, 4815, 5, 56, 0, 0, 4815, 567, 1, 0, 0, 0, 4816, 4833, 5, 382, 0, 0, 4817, 4818, 5, 383, 0, 0, 4818, 4820, 5, 394, 0, 0, 4819, 4821, 5, 90, 0, 0, 4820, 4819, 1, 0, 0, 0, 4820, 4821, 1, 0, 0, 0, 4821, 4823, 1, 0, 0, 0, 4822, 4824, 5, 190, 0, 0, 4823, 4822, 1, 0, 0, 0, 4823, 4824, 1, 0, 0, 0, 4824, 4826, 1, 0, 0, 0, 4825, 4827, 5, 395, 0, 0, 4826, 4825, 1, 0, 0, 0, 4826, 4827, 1, 0, 0, 0, 4827, 4829, 1, 0, 0, 0, 4828, 4830, 5, 396, 0, 0, 4829, 4828, 1, 0, 0, 0, 4829, 4830, 1, 0, 0, 0, 4830, 4833, 1, 0, 0, 0, 4831, 4833, 5, 383, 0, 0, 4832, 4816, 1, 0, 0, 0, 4832, 4817, 1, 0, 0, 0, 4832, 4831, 1, 0, 0, 0, 4833, 569, 1, 0, 0, 0, 4834, 4835, 5, 384, 0, 0, 4835, 571, 1, 0, 0, 0, 4836, 4837, 5, 385, 0, 0, 4837, 573, 1, 0, 0, 0, 4838, 4839, 5, 386, 0, 0, 4839, 4840, 5, 387, 0, 0, 4840, 4841, 5, 478, 0, 0, 4841, 575, 1, 0, 0, 0, 4842, 4843, 5, 386, 0, 0, 4843, 4844, 5, 59, 0, 0, 4844, 4845, 5, 478, 0, 0, 4845, 577, 1, 0, 0, 0, 4846, 4848, 5, 388, 0, 0, 4847, 4849, 3, 580, 290, 0, 4848, 4847, 1, 0, 0, 0, 4848, 4849, 1, 0, 0, 0, 4849, 4852, 1, 0, 0, 0, 4850, 4851, 5, 417, 0, 0, 4851, 4853, 3, 582, 291, 0, 4852, 4850, 1, 0, 0, 0, 4852, 4853, 1, 0, 0, 0, 4853, 4858, 1, 0, 0, 0, 4854, 4855, 5, 64, 0, 0, 4855, 4856, 5, 388, 0, 0, 4856, 4858, 5, 389, 0, 0, 4857, 4846, 1, 0, 0, 0, 4857, 4854, 1, 0, 0, 0, 4858, 579, 1, 0, 0, 0, 4859, 4860, 3, 646, 323, 0, 4860, 4861, 5, 463, 0, 0, 4861, 4862, 5, 456, 0, 0, 4862, 4866, 1, 0, 0, 0, 4863, 4866, 3, 646, 323, 0, 4864, 4866, 5, 456, 0, 0, 4865, 4859, 1, 0, 0, 0, 4865, 4863, 1, 0, 0, 0, 4865, 4864, 1, 0, 0, 0, 4866, 581, 1, 0, 0, 0, 4867, 4868, 7, 33, 0, 0, 4868, 583, 1, 0, 0, 0, 4869, 4870, 5, 66, 0, 0, 4870, 4874, 3, 586, 293, 0, 4871, 4872, 5, 66, 0, 0, 4872, 4874, 5, 84, 0, 0, 4873, 4869, 1, 0, 0, 0, 4873, 4871, 1, 0, 0, 0, 4874, 585, 1, 0, 0, 0, 4875, 4880, 3, 588, 294, 0, 4876, 4877, 5, 462, 0, 0, 4877, 4879, 3, 588, 294, 0, 4878, 4876, 1, 0, 0, 0, 4879, 4882, 1, 0, 0, 0, 4880, 4878, 1, 0, 0, 0, 4880, 4881, 1, 0, 0, 0, 4881, 587, 1, 0, 0, 0, 4882, 4880, 1, 0, 0, 0, 4883, 4884, 7, 34, 0, 0, 4884, 589, 1, 0, 0, 0, 4885, 4886, 5, 67, 0, 0, 4886, 4887, 5, 330, 0, 0, 4887, 591, 1, 0, 0, 0, 4888, 4889, 5, 68, 0, 0, 4889, 4890, 5, 478, 0, 0, 4890, 593, 1, 0, 0, 0, 4891, 4892, 5, 418, 0, 0, 4892, 4893, 5, 55, 0, 0, 4893, 4894, 5, 482, 0, 0, 4894, 4895, 5, 478, 0, 0, 4895, 4896, 5, 75, 0, 0, 4896, 4951, 5, 482, 0, 0, 4897, 4898, 5, 418, 0, 0, 4898, 4899, 5, 56, 0, 0, 4899, 4951, 5, 482, 0, 0, 4900, 4901, 5, 418, 0, 0, 4901, 4951, 5, 375, 0, 0, 4902, 4903, 5, 418, 0, 0, 4903, 4904, 5, 482, 0, 0, 4904, 4905, 5, 64, 0, 0, 4905, 4951, 5, 482, 0, 0, 4906, 4907, 5, 418, 0, 0, 4907, 4908, 5, 482, 0, 0, 4908, 4909, 5, 65, 0, 0, 4909, 4951, 5, 482, 0, 0, 4910, 4911, 5, 418, 0, 0, 4911, 4912, 5, 482, 0, 0, 4912, 4913, 5, 352, 0, 0, 4913, 4914, 5, 353, 0, 0, 4914, 4915, 5, 348, 0, 0, 4915, 4928, 3, 648, 324, 0, 4916, 4917, 5, 355, 0, 0, 4917, 4918, 5, 464, 0, 0, 4918, 4923, 3, 648, 324, 0, 4919, 4920, 5, 462, 0, 0, 4920, 4922, 3, 648, 324, 0, 4921, 4919, 1, 0, 0, 0, 4922, 4925, 1, 0, 0, 0, 4923, 4921, 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4926, 1, 0, 0, 0, 4925, 4923, 1, 0, 0, 0, 4926, 4927, 5, 465, 0, 0, 4927, 4929, 1, 0, 0, 0, 4928, 4916, 1, 0, 0, 0, 4928, 4929, 1, 0, 0, 0, 4929, 4942, 1, 0, 0, 0, 4930, 4931, 5, 356, 0, 0, 4931, 4932, 5, 464, 0, 0, 4932, 4937, 3, 648, 324, 0, 4933, 4934, 5, 462, 0, 0, 4934, 4936, 3, 648, 324, 0, 4935, 4933, 1, 0, 0, 0, 4936, 4939, 1, 0, 0, 0, 4937, 4935, 1, 0, 0, 0, 4937, 4938, 1, 0, 0, 0, 4938, 4940, 1, 0, 0, 0, 4939, 4937, 1, 0, 0, 0, 4940, 4941, 5, 465, 0, 0, 4941, 4943, 1, 0, 0, 0, 4942, 4930, 1, 0, 0, 0, 4942, 4943, 1, 0, 0, 0, 4943, 4945, 1, 0, 0, 0, 4944, 4946, 5, 354, 0, 0, 4945, 4944, 1, 0, 0, 0, 4945, 4946, 1, 0, 0, 0, 4946, 4951, 1, 0, 0, 0, 4947, 4948, 5, 418, 0, 0, 4948, 4949, 5, 482, 0, 0, 4949, 4951, 3, 596, 298, 0, 4950, 4891, 1, 0, 0, 0, 4950, 4897, 1, 0, 0, 0, 4950, 4900, 1, 0, 0, 0, 4950, 4902, 1, 0, 0, 0, 4950, 4906, 1, 0, 0, 0, 4950, 4910, 1, 0, 0, 0, 4950, 4947, 1, 0, 0, 0, 4951, 595, 1, 0, 0, 0, 4952, 4954, 8, 35, 0, 0, 4953, 4952, 1, 0, 0, 0, 4954, 4955, 1, 0, 0, 0, 4955, 4953, 1, 0, 0, 0, 4955, 4956, 1, 0, 0, 0, 4956, 597, 1, 0, 0, 0, 4957, 4958, 5, 347, 0, 0, 4958, 4959, 5, 70, 0, 0, 4959, 4960, 3, 648, 324, 0, 4960, 4961, 5, 344, 0, 0, 4961, 4962, 7, 25, 0, 0, 4962, 4963, 5, 348, 0, 0, 4963, 4964, 3, 646, 323, 0, 4964, 4965, 5, 345, 0, 0, 4965, 4966, 5, 464, 0, 0, 4966, 4971, 3, 600, 300, 0, 4967, 4968, 5, 462, 0, 0, 4968, 4970, 3, 600, 300, 0, 4969, 4967, 1, 0, 0, 0, 4970, 4973, 1, 0, 0, 0, 4971, 4969, 1, 0, 0, 0, 4971, 4972, 1, 0, 0, 0, 4972, 4974, 1, 0, 0, 0, 4973, 4971, 1, 0, 0, 0, 4974, 4987, 5, 465, 0, 0, 4975, 4976, 5, 350, 0, 0, 4976, 4977, 5, 464, 0, 0, 4977, 4982, 3, 602, 301, 0, 4978, 4979, 5, 462, 0, 0, 4979, 4981, 3, 602, 301, 0, 4980, 4978, 1, 0, 0, 0, 4981, 4984, 1, 0, 0, 0, 4982, 4980, 1, 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 4985, 1, 0, 0, 0, 4984, 4982, 1, 0, 0, 0, 4985, 4986, 5, 465, 0, 0, 4986, 4988, 1, 0, 0, 0, 4987, 4975, 1, 0, 0, 0, 4987, 4988, 1, 0, 0, 0, 4988, 4991, 1, 0, 0, 0, 4989, 4990, 5, 349, 0, 0, 4990, 4992, 5, 480, 0, 0, 4991, 4989, 1, 0, 0, 0, 4991, 4992, 1, 0, 0, 0, 4992, 4995, 1, 0, 0, 0, 4993, 4994, 5, 74, 0, 0, 4994, 4996, 5, 480, 0, 0, 4995, 4993, 1, 0, 0, 0, 4995, 4996, 1, 0, 0, 0, 4996, 599, 1, 0, 0, 0, 4997, 4998, 3, 648, 324, 0, 4998, 4999, 5, 75, 0, 0, 4999, 5000, 3, 648, 324, 0, 5000, 601, 1, 0, 0, 0, 5001, 5002, 3, 648, 324, 0, 5002, 5003, 5, 410, 0, 0, 5003, 5004, 3, 648, 324, 0, 5004, 5005, 5, 92, 0, 0, 5005, 5006, 3, 648, 324, 0, 5006, 5012, 1, 0, 0, 0, 5007, 5008, 3, 648, 324, 0, 5008, 5009, 5, 410, 0, 0, 5009, 5010, 3, 648, 324, 0, 5010, 5012, 1, 0, 0, 0, 5011, 5001, 1, 0, 0, 0, 5011, 5007, 1, 0, 0, 0, 5012, 603, 1, 0, 0, 0, 5013, 5014, 5, 482, 0, 0, 5014, 605, 1, 0, 0, 0, 5015, 5016, 5, 376, 0, 0, 5016, 5017, 5, 377, 0, 0, 5017, 5018, 3, 648, 324, 0, 5018, 5019, 5, 75, 0, 0, 5019, 5020, 5, 466, 0, 0, 5020, 5021, 3, 364, 182, 0, 5021, 5022, 5, 467, 0, 0, 5022, 607, 1, 0, 0, 0, 5023, 5024, 3, 610, 305, 0, 5024, 609, 1, 0, 0, 0, 5025, 5030, 3, 612, 306, 0, 5026, 5027, 5, 281, 0, 0, 5027, 5029, 3, 612, 306, 0, 5028, 5026, 1, 0, 0, 0, 5029, 5032, 1, 0, 0, 0, 5030, 5028, 1, 0, 0, 0, 5030, 5031, 1, 0, 0, 0, 5031, 611, 1, 0, 0, 0, 5032, 5030, 1, 0, 0, 0, 5033, 5038, 3, 614, 307, 0, 5034, 5035, 5, 280, 0, 0, 5035, 5037, 3, 614, 307, 0, 5036, 5034, 1, 0, 0, 0, 5037, 5040, 1, 0, 0, 0, 5038, 5036, 1, 0, 0, 0, 5038, 5039, 1, 0, 0, 0, 5039, 613, 1, 0, 0, 0, 5040, 5038, 1, 0, 0, 0, 5041, 5043, 5, 282, 0, 0, 5042, 5041, 1, 0, 0, 0, 5042, 5043, 1, 0, 0, 0, 5043, 5044, 1, 0, 0, 0, 5044, 5045, 3, 616, 308, 0, 5045, 615, 1, 0, 0, 0, 5046, 5075, 3, 620, 310, 0, 5047, 5048, 3, 618, 309, 0, 5048, 5049, 3, 620, 310, 0, 5049, 5076, 1, 0, 0, 0, 5050, 5076, 5, 6, 0, 0, 5051, 5076, 5, 5, 0, 0, 5052, 5053, 5, 284, 0, 0, 5053, 5056, 5, 464, 0, 0, 5054, 5057, 3, 522, 261, 0, 5055, 5057, 3, 644, 322, 0, 5056, 5054, 1, 0, 0, 0, 5056, 5055, 1, 0, 0, 0, 5057, 5058, 1, 0, 0, 0, 5058, 5059, 5, 465, 0, 0, 5059, 5076, 1, 0, 0, 0, 5060, 5062, 5, 282, 0, 0, 5061, 5060, 1, 0, 0, 0, 5061, 5062, 1, 0, 0, 0, 5062, 5063, 1, 0, 0, 0, 5063, 5064, 5, 285, 0, 0, 5064, 5065, 3, 620, 310, 0, 5065, 5066, 5, 280, 0, 0, 5066, 5067, 3, 620, 310, 0, 5067, 5076, 1, 0, 0, 0, 5068, 5070, 5, 282, 0, 0, 5069, 5068, 1, 0, 0, 0, 5069, 5070, 1, 0, 0, 0, 5070, 5071, 1, 0, 0, 0, 5071, 5072, 5, 286, 0, 0, 5072, 5076, 3, 620, 310, 0, 5073, 5074, 5, 287, 0, 0, 5074, 5076, 3, 620, 310, 0, 5075, 5047, 1, 0, 0, 0, 5075, 5050, 1, 0, 0, 0, 5075, 5051, 1, 0, 0, 0, 5075, 5052, 1, 0, 0, 0, 5075, 5061, 1, 0, 0, 0, 5075, 5069, 1, 0, 0, 0, 5075, 5073, 1, 0, 0, 0, 5075, 5076, 1, 0, 0, 0, 5076, 617, 1, 0, 0, 0, 5077, 5078, 7, 36, 0, 0, 5078, 619, 1, 0, 0, 0, 5079, 5084, 3, 622, 311, 0, 5080, 5081, 7, 37, 0, 0, 5081, 5083, 3, 622, 311, 0, 5082, 5080, 1, 0, 0, 0, 5083, 5086, 1, 0, 0, 0, 5084, 5082, 1, 0, 0, 0, 5084, 5085, 1, 0, 0, 0, 5085, 621, 1, 0, 0, 0, 5086, 5084, 1, 0, 0, 0, 5087, 5092, 3, 624, 312, 0, 5088, 5089, 7, 38, 0, 0, 5089, 5091, 3, 624, 312, 0, 5090, 5088, 1, 0, 0, 0, 5091, 5094, 1, 0, 0, 0, 5092, 5090, 1, 0, 0, 0, 5092, 5093, 1, 0, 0, 0, 5093, 623, 1, 0, 0, 0, 5094, 5092, 1, 0, 0, 0, 5095, 5097, 7, 37, 0, 0, 5096, 5095, 1, 0, 0, 0, 5096, 5097, 1, 0, 0, 0, 5097, 5098, 1, 0, 0, 0, 5098, 5099, 3, 626, 313, 0, 5099, 625, 1, 0, 0, 0, 5100, 5101, 5, 464, 0, 0, 5101, 5102, 3, 608, 304, 0, 5102, 5103, 5, 465, 0, 0, 5103, 5121, 1, 0, 0, 0, 5104, 5105, 5, 464, 0, 0, 5105, 5106, 3, 522, 261, 0, 5106, 5107, 5, 465, 0, 0, 5107, 5121, 1, 0, 0, 0, 5108, 5109, 5, 288, 0, 0, 5109, 5110, 5, 464, 0, 0, 5110, 5111, 3, 522, 261, 0, 5111, 5112, 5, 465, 0, 0, 5112, 5121, 1, 0, 0, 0, 5113, 5121, 3, 628, 314, 0, 5114, 5121, 3, 630, 315, 0, 5115, 5121, 3, 288, 144, 0, 5116, 5121, 3, 280, 140, 0, 5117, 5121, 3, 634, 317, 0, 5118, 5121, 3, 636, 318, 0, 5119, 5121, 3, 642, 321, 0, 5120, 5100, 1, 0, 0, 0, 5120, 5104, 1, 0, 0, 0, 5120, 5108, 1, 0, 0, 0, 5120, 5113, 1, 0, 0, 0, 5120, 5114, 1, 0, 0, 0, 5120, 5115, 1, 0, 0, 0, 5120, 5116, 1, 0, 0, 0, 5120, 5117, 1, 0, 0, 0, 5120, 5118, 1, 0, 0, 0, 5120, 5119, 1, 0, 0, 0, 5121, 627, 1, 0, 0, 0, 5122, 5128, 5, 78, 0, 0, 5123, 5124, 5, 79, 0, 0, 5124, 5125, 3, 608, 304, 0, 5125, 5126, 5, 80, 0, 0, 5126, 5127, 3, 608, 304, 0, 5127, 5129, 1, 0, 0, 0, 5128, 5123, 1, 0, 0, 0, 5129, 5130, 1, 0, 0, 0, 5130, 5128, 1, 0, 0, 0, 5130, 5131, 1, 0, 0, 0, 5131, 5134, 1, 0, 0, 0, 5132, 5133, 5, 81, 0, 0, 5133, 5135, 3, 608, 304, 0, 5134, 5132, 1, 0, 0, 0, 5134, 5135, 1, 0, 0, 0, 5135, 5136, 1, 0, 0, 0, 5136, 5137, 5, 82, 0, 0, 5137, 629, 1, 0, 0, 0, 5138, 5139, 5, 279, 0, 0, 5139, 5140, 5, 464, 0, 0, 5140, 5141, 3, 608, 304, 0, 5141, 5142, 5, 75, 0, 0, 5142, 5143, 3, 632, 316, 0, 5143, 5144, 5, 465, 0, 0, 5144, 631, 1, 0, 0, 0, 5145, 5146, 7, 39, 0, 0, 5146, 633, 1, 0, 0, 0, 5147, 5148, 7, 40, 0, 0, 5148, 5154, 5, 464, 0, 0, 5149, 5151, 5, 83, 0, 0, 5150, 5149, 1, 0, 0, 0, 5150, 5151, 1, 0, 0, 0, 5151, 5152, 1, 0, 0, 0, 5152, 5155, 3, 608, 304, 0, 5153, 5155, 5, 456, 0, 0, 5154, 5150, 1, 0, 0, 0, 5154, 5153, 1, 0, 0, 0, 5155, 5156, 1, 0, 0, 0, 5156, 5157, 5, 465, 0, 0, 5157, 635, 1, 0, 0, 0, 5158, 5159, 3, 638, 319, 0, 5159, 5161, 5, 464, 0, 0, 5160, 5162, 3, 640, 320, 0, 5161, 5160, 1, 0, 0, 0, 5161, 5162, 1, 0, 0, 0, 5162, 5163, 1, 0, 0, 0, 5163, 5164, 5, 465, 0, 0, 5164, 637, 1, 0, 0, 0, 5165, 5166, 7, 41, 0, 0, 5166, 639, 1, 0, 0, 0, 5167, 5172, 3, 608, 304, 0, 5168, 5169, 5, 462, 0, 0, 5169, 5171, 3, 608, 304, 0, 5170, 5168, 1, 0, 0, 0, 5171, 5174, 1, 0, 0, 0, 5172, 5170, 1, 0, 0, 0, 5172, 5173, 1, 0, 0, 0, 5173, 641, 1, 0, 0, 0, 5174, 5172, 1, 0, 0, 0, 5175, 5188, 3, 650, 325, 0, 5176, 5181, 5, 481, 0, 0, 5177, 5178, 5, 463, 0, 0, 5178, 5180, 3, 94, 47, 0, 5179, 5177, 1, 0, 0, 0, 5180, 5183, 1, 0, 0, 0, 5181, 5179, 1, 0, 0, 0, 5181, 5182, 1, 0, 0, 0, 5182, 5188, 1, 0, 0, 0, 5183, 5181, 1, 0, 0, 0, 5184, 5188, 3, 646, 323, 0, 5185, 5188, 5, 482, 0, 0, 5186, 5188, 5, 477, 0, 0, 5187, 5175, 1, 0, 0, 0, 5187, 5176, 1, 0, 0, 0, 5187, 5184, 1, 0, 0, 0, 5187, 5185, 1, 0, 0, 0, 5187, 5186, 1, 0, 0, 0, 5188, 643, 1, 0, 0, 0, 5189, 5194, 3, 608, 304, 0, 5190, 5191, 5, 462, 0, 0, 5191, 5193, 3, 608, 304, 0, 5192, 5190, 1, 0, 0, 0, 5193, 5196, 1, 0, 0, 0, 5194, 5192, 1, 0, 0, 0, 5194, 5195, 1, 0, 0, 0, 5195, 645, 1, 0, 0, 0, 5196, 5194, 1, 0, 0, 0, 5197, 5202, 3, 648, 324, 0, 5198, 5199, 5, 463, 0, 0, 5199, 5201, 3, 648, 324, 0, 5200, 5198, 1, 0, 0, 0, 5201, 5204, 1, 0, 0, 0, 5202, 5200, 1, 0, 0, 0, 5202, 5203, 1, 0, 0, 0, 5203, 647, 1, 0, 0, 0, 5204, 5202, 1, 0, 0, 0, 5205, 5209, 5, 482, 0, 0, 5206, 5209, 5, 484, 0, 0, 5207, 5209, 3, 670, 335, 0, 5208, 5205, 1, 0, 0, 0, 5208, 5206, 1, 0, 0, 0, 5208, 5207, 1, 0, 0, 0, 5209, 649, 1, 0, 0, 0, 5210, 5216, 5, 478, 0, 0, 5211, 5216, 5, 480, 0, 0, 5212, 5216, 3, 654, 327, 0, 5213, 5216, 5, 283, 0, 0, 5214, 5216, 5, 138, 0, 0, 5215, 5210, 1, 0, 0, 0, 5215, 5211, 1, 0, 0, 0, 5215, 5212, 1, 0, 0, 0, 5215, 5213, 1, 0, 0, 0, 5215, 5214, 1, 0, 0, 0, 5216, 651, 1, 0, 0, 0, 5217, 5226, 5, 468, 0, 0, 5218, 5223, 3, 650, 325, 0, 5219, 5220, 5, 462, 0, 0, 5220, 5222, 3, 650, 325, 0, 5221, 5219, 1, 0, 0, 0, 5222, 5225, 1, 0, 0, 0, 5223, 5221, 1, 0, 0, 0, 5223, 5224, 1, 0, 0, 0, 5224, 5227, 1, 0, 0, 0, 5225, 5223, 1, 0, 0, 0, 5226, 5218, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, 0, 5227, 5228, 1, 0, 0, 0, 5228, 5229, 5, 469, 0, 0, 5229, 653, 1, 0, 0, 0, 5230, 5231, 7, 42, 0, 0, 5231, 655, 1, 0, 0, 0, 5232, 5233, 5, 2, 0, 0, 5233, 657, 1, 0, 0, 0, 5234, 5235, 5, 471, 0, 0, 5235, 5241, 3, 660, 330, 0, 5236, 5237, 5, 464, 0, 0, 5237, 5238, 3, 662, 331, 0, 5238, 5239, 5, 465, 0, 0, 5239, 5242, 1, 0, 0, 0, 5240, 5242, 3, 666, 333, 0, 5241, 5236, 1, 0, 0, 0, 5241, 5240, 1, 0, 0, 0, 5241, 5242, 1, 0, 0, 0, 5242, 659, 1, 0, 0, 0, 5243, 5244, 7, 43, 0, 0, 5244, 661, 1, 0, 0, 0, 5245, 5250, 3, 664, 332, 0, 5246, 5247, 5, 462, 0, 0, 5247, 5249, 3, 664, 332, 0, 5248, 5246, 1, 0, 0, 0, 5249, 5252, 1, 0, 0, 0, 5250, 5248, 1, 0, 0, 0, 5250, 5251, 1, 0, 0, 0, 5251, 663, 1, 0, 0, 0, 5252, 5250, 1, 0, 0, 0, 5253, 5254, 5, 482, 0, 0, 5254, 5255, 5, 470, 0, 0, 5255, 5258, 3, 666, 333, 0, 5256, 5258, 3, 666, 333, 0, 5257, 5253, 1, 0, 0, 0, 5257, 5256, 1, 0, 0, 0, 5258, 665, 1, 0, 0, 0, 5259, 5263, 3, 650, 325, 0, 5260, 5263, 3, 608, 304, 0, 5261, 5263, 3, 646, 323, 0, 5262, 5259, 1, 0, 0, 0, 5262, 5260, 1, 0, 0, 0, 5262, 5261, 1, 0, 0, 0, 5263, 667, 1, 0, 0, 0, 5264, 5265, 7, 44, 0, 0, 5265, 669, 1, 0, 0, 0, 5266, 5267, 7, 45, 0, 0, 5267, 671, 1, 0, 0, 0, 603, 675, 681, 686, 689, 692, 701, 711, 720, 726, 728, 732, 735, 740, 746, 767, 775, 783, 791, 799, 811, 824, 837, 849, 860, 864, 872, 878, 895, 899, 903, 907, 911, 913, 927, 936, 945, 961, 970, 985, 999, 1003, 1012, 1015, 1023, 1028, 1030, 1085, 1098, 1109, 1118, 1120, 1131, 1137, 1145, 1147, 1166, 1174, 1191, 1215, 1231, 1299, 1313, 1327, 1334, 1342, 1356, 1369, 1373, 1379, 1382, 1388, 1391, 1397, 1401, 1405, 1411, 1416, 1419, 1421, 1427, 1431, 1435, 1438, 1442, 1447, 1454, 1461, 1465, 1470, 1479, 1485, 1490, 1496, 1501, 1506, 1511, 1513, 1519, 1551, 1559, 1580, 1583, 1594, 1599, 1604, 1613, 1618, 1630, 1659, 1669, 1690, 1704, 1711, 1724, 1731, 1739, 1744, 1749, 1755, 1763, 1770, 1774, 1778, 1781, 1798, 1803, 1842, 1857, 1864, 1872, 1879, 1883, 1886, 1892, 1895, 1902, 1906, 1909, 1914, 1921, 1928, 1944, 1949, 1957, 1963, 1968, 1974, 1979, 1985, 1990, 1995, 2000, 2005, 2010, 2015, 2020, 2025, 2030, 2035, 2040, 2045, 2050, 2055, 2060, 2065, 2070, 2075, 2080, 2085, 2090, 2095, 2100, 2105, 2110, 2115, 2120, 2125, 2130, 2135, 2140, 2145, 2150, 2155, 2160, 2165, 2170, 2175, 2180, 2185, 2190, 2195, 2200, 2205, 2210, 2215, 2220, 2225, 2230, 2235, 2240, 2245, 2250, 2255, 2260, 2265, 2270, 2275, 2280, 2285, 2290, 2295, 2300, 2302, 2309, 2314, 2321, 2327, 2330, 2333, 2339, 2342, 2348, 2352, 2358, 2361, 2364, 2369, 2374, 2383, 2385, 2393, 2396, 2400, 2404, 2407, 2416, 2438, 2451, 2456, 2466, 2476, 2481, 2489, 2496, 2500, 2504, 2515, 2522, 2536, 2543, 2547, 2551, 2559, 2563, 2567, 2577, 2579, 2583, 2586, 2591, 2594, 2597, 2601, 2609, 2613, 2620, 2625, 2635, 2638, 2642, 2646, 2653, 2660, 2666, 2680, 2687, 2702, 2706, 2713, 2718, 2722, 2725, 2728, 2732, 2738, 2756, 2761, 2769, 2788, 2853, 2860, 2865, 2895, 2918, 2929, 2936, 2953, 2956, 2965, 2975, 2987, 2999, 3010, 3013, 3026, 3034, 3040, 3046, 3054, 3061, 3069, 3076, 3083, 3095, 3098, 3110, 3134, 3142, 3150, 3170, 3174, 3176, 3184, 3189, 3192, 3202, 3282, 3292, 3300, 3310, 3314, 3316, 3324, 3327, 3332, 3337, 3343, 3347, 3351, 3357, 3363, 3368, 3373, 3378, 3383, 3391, 3402, 3407, 3413, 3417, 3426, 3428, 3430, 3438, 3474, 3477, 3480, 3488, 3495, 3506, 3515, 3521, 3529, 3538, 3546, 3552, 3556, 3565, 3577, 3583, 3585, 3598, 3602, 3614, 3619, 3621, 3636, 3641, 3654, 3662, 3673, 3683, 3692, 3699, 3709, 3720, 3739, 3744, 3755, 3760, 3766, 3770, 3778, 3781, 3797, 3805, 3808, 3815, 3823, 3828, 3831, 3834, 3844, 3847, 3854, 3857, 3865, 3883, 3889, 3892, 3897, 3902, 3912, 3931, 3939, 3951, 3958, 3962, 3976, 3986, 3995, 3998, 4010, 4016, 4025, 4027, 4034, 4036, 4043, 4045, 4052, 4054, 4061, 4063, 4070, 4072, 4079, 4081, 4088, 4090, 4097, 4099, 4106, 4108, 4115, 4117, 4125, 4127, 4155, 4162, 4178, 4183, 4194, 4196, 4224, 4226, 4234, 4236, 4244, 4246, 4254, 4256, 4265, 4275, 4281, 4286, 4288, 4291, 4300, 4302, 4311, 4313, 4321, 4323, 4335, 4337, 4339, 4347, 4353, 4355, 4360, 4362, 4372, 4382, 4423, 4453, 4462, 4498, 4502, 4510, 4513, 4518, 4523, 4529, 4531, 4535, 4539, 4543, 4546, 4553, 4556, 4560, 4567, 4572, 4577, 4580, 4583, 4586, 4589, 4592, 4596, 4599, 4602, 4606, 4609, 4611, 4615, 4625, 4628, 4633, 4638, 4640, 4644, 4651, 4656, 4659, 4665, 4668, 4670, 4673, 4679, 4682, 4687, 4690, 4692, 4704, 4708, 4712, 4717, 4720, 4739, 4744, 4751, 4758, 4764, 4766, 4784, 4795, 4810, 4812, 4820, 4823, 4826, 4829, 4832, 4848, 4852, 4857, 4865, 4873, 4880, 4923, 4928, 4937, 4942, 4945, 4950, 4955, 4971, 4982, 4987, 4991, 4995, 5011, 5030, 5038, 5042, 5056, 5061, 5069, 5075, 5084, 5092, 5096, 5120, 5130, 5134, 5150, 5154, 5161, 5172, 5181, 5187, 5194, 5202, 5208, 5215, 5223, 5226, 5241, 5250, 5257, 5262] \ No newline at end of file +[4, 1, 505, 5698, 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, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 1, 0, 5, 0, 712, 8, 0, 10, 0, 12, 0, 715, 9, 0, 1, 0, 1, 0, 1, 1, 3, 1, 720, 8, 1, 1, 1, 1, 1, 1, 1, 3, 1, 725, 8, 1, 1, 1, 3, 1, 728, 8, 1, 1, 1, 3, 1, 731, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 740, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 748, 8, 3, 10, 3, 12, 3, 751, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 757, 8, 3, 10, 3, 12, 3, 760, 9, 3, 1, 3, 1, 3, 1, 3, 3, 3, 765, 8, 3, 3, 3, 767, 8, 3, 1, 3, 1, 3, 3, 3, 771, 8, 3, 1, 4, 3, 4, 774, 8, 4, 1, 4, 5, 4, 777, 8, 4, 10, 4, 12, 4, 780, 9, 4, 1, 4, 1, 4, 1, 4, 3, 4, 785, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 807, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 813, 8, 5, 11, 5, 12, 5, 814, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 821, 8, 5, 11, 5, 12, 5, 822, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 829, 8, 5, 11, 5, 12, 5, 830, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 837, 8, 5, 11, 5, 12, 5, 838, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 849, 8, 5, 10, 5, 12, 5, 852, 9, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 862, 8, 5, 10, 5, 12, 5, 865, 9, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 875, 8, 5, 11, 5, 12, 5, 876, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 887, 8, 5, 11, 5, 12, 5, 888, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 898, 8, 5, 11, 5, 12, 5, 899, 1, 5, 1, 5, 3, 5, 904, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 5, 6, 910, 8, 6, 10, 6, 12, 6, 913, 9, 6, 1, 6, 1, 6, 1, 6, 3, 6, 918, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 935, 8, 7, 1, 8, 1, 8, 3, 8, 939, 8, 8, 1, 8, 1, 8, 3, 8, 943, 8, 8, 1, 8, 1, 8, 3, 8, 947, 8, 8, 1, 8, 1, 8, 3, 8, 951, 8, 8, 3, 8, 953, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 965, 8, 9, 10, 9, 12, 9, 968, 9, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 976, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 985, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1001, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 1008, 8, 12, 10, 12, 12, 12, 1011, 9, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1025, 8, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 1037, 8, 14, 10, 14, 12, 14, 1040, 9, 14, 1, 14, 3, 14, 1043, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1052, 8, 15, 1, 15, 3, 15, 1055, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1061, 8, 15, 10, 15, 12, 15, 1064, 9, 15, 1, 15, 1, 15, 3, 15, 1068, 8, 15, 3, 15, 1070, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1128, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1141, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1152, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1161, 8, 18, 3, 18, 1163, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1174, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1180, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1188, 8, 18, 3, 18, 1190, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1211, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 1219, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 1236, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 1260, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1276, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1360, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1370, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 1376, 8, 36, 10, 36, 12, 36, 1379, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1392, 8, 38, 1, 39, 1, 39, 1, 39, 5, 39, 1397, 8, 39, 10, 39, 12, 39, 1400, 9, 39, 1, 40, 1, 40, 1, 40, 5, 40, 1405, 8, 40, 10, 40, 12, 40, 1408, 9, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 1419, 8, 41, 10, 41, 12, 41, 1422, 9, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 1432, 8, 41, 10, 41, 12, 41, 1435, 9, 41, 1, 41, 3, 41, 1438, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1444, 8, 42, 1, 42, 3, 42, 1447, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1453, 8, 42, 1, 42, 3, 42, 1456, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1462, 8, 42, 1, 42, 1, 42, 3, 42, 1466, 8, 42, 1, 42, 1, 42, 3, 42, 1470, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1476, 8, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1481, 8, 42, 1, 42, 3, 42, 1484, 8, 42, 3, 42, 1486, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 1492, 8, 43, 1, 44, 1, 44, 3, 44, 1496, 8, 44, 1, 44, 1, 44, 3, 44, 1500, 8, 44, 1, 44, 3, 44, 1503, 8, 44, 1, 45, 1, 45, 3, 45, 1507, 8, 45, 1, 45, 5, 45, 1510, 8, 45, 10, 45, 12, 45, 1513, 9, 45, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1519, 8, 46, 1, 47, 1, 47, 1, 47, 5, 47, 1524, 8, 47, 10, 47, 12, 47, 1527, 9, 47, 1, 48, 3, 48, 1530, 8, 48, 1, 48, 5, 48, 1533, 8, 48, 10, 48, 12, 48, 1536, 9, 48, 1, 48, 1, 48, 1, 48, 1, 48, 5, 48, 1542, 8, 48, 10, 48, 12, 48, 1545, 9, 48, 1, 49, 1, 49, 1, 49, 3, 49, 1550, 8, 49, 1, 50, 1, 50, 1, 50, 3, 50, 1555, 8, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1561, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1566, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1571, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1576, 8, 50, 1, 50, 1, 50, 3, 50, 1580, 8, 50, 1, 50, 3, 50, 1583, 8, 50, 3, 50, 1585, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1591, 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1623, 8, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1631, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1652, 8, 53, 1, 54, 3, 54, 1655, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 5, 55, 1664, 8, 55, 10, 55, 12, 55, 1667, 9, 55, 1, 56, 1, 56, 3, 56, 1671, 8, 56, 1, 57, 1, 57, 1, 57, 3, 57, 1676, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1685, 8, 58, 1, 59, 4, 59, 1688, 8, 59, 11, 59, 12, 59, 1689, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1702, 8, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 1729, 8, 62, 10, 62, 12, 62, 1732, 9, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 1739, 8, 62, 10, 62, 12, 62, 1742, 9, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1762, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1776, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1783, 8, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1796, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1803, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1811, 8, 65, 1, 66, 1, 66, 1, 66, 3, 66, 1816, 8, 66, 1, 67, 4, 67, 1819, 8, 67, 11, 67, 12, 67, 1820, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1827, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1835, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 1840, 8, 70, 10, 70, 12, 70, 1843, 9, 70, 1, 71, 3, 71, 1846, 8, 71, 1, 71, 1, 71, 3, 71, 1850, 8, 71, 1, 71, 3, 71, 1853, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1870, 8, 72, 1, 73, 4, 73, 1873, 8, 73, 11, 73, 12, 73, 1874, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1914, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1929, 8, 77, 1, 78, 1, 78, 1, 78, 5, 78, 1934, 8, 78, 10, 78, 12, 78, 1937, 9, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1942, 8, 79, 10, 79, 12, 79, 1945, 9, 79, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1951, 8, 80, 1, 80, 1, 80, 3, 80, 1955, 8, 80, 1, 80, 3, 80, 1958, 8, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1964, 8, 80, 1, 80, 3, 80, 1967, 8, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1974, 8, 81, 1, 81, 1, 81, 3, 81, 1978, 8, 81, 1, 81, 3, 81, 1981, 8, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1986, 8, 81, 1, 82, 1, 82, 1, 82, 5, 82, 1991, 8, 82, 10, 82, 12, 82, 1994, 9, 82, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 2000, 8, 83, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 5, 86, 2014, 8, 86, 10, 86, 12, 86, 2017, 9, 86, 1, 87, 1, 87, 3, 87, 2021, 8, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 3, 88, 2029, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2035, 8, 89, 1, 90, 4, 90, 2038, 8, 90, 11, 90, 12, 90, 2039, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2046, 8, 91, 1, 92, 5, 92, 2049, 8, 92, 10, 92, 12, 92, 2052, 9, 92, 1, 93, 5, 93, 2055, 8, 93, 10, 93, 12, 93, 2058, 9, 93, 1, 93, 1, 93, 3, 93, 2062, 8, 93, 1, 93, 5, 93, 2065, 8, 93, 10, 93, 12, 93, 2068, 9, 93, 1, 93, 1, 93, 3, 93, 2072, 8, 93, 1, 93, 5, 93, 2075, 8, 93, 10, 93, 12, 93, 2078, 9, 93, 1, 93, 1, 93, 3, 93, 2082, 8, 93, 1, 93, 5, 93, 2085, 8, 93, 10, 93, 12, 93, 2088, 9, 93, 1, 93, 1, 93, 3, 93, 2092, 8, 93, 1, 93, 5, 93, 2095, 8, 93, 10, 93, 12, 93, 2098, 9, 93, 1, 93, 1, 93, 3, 93, 2102, 8, 93, 1, 93, 5, 93, 2105, 8, 93, 10, 93, 12, 93, 2108, 9, 93, 1, 93, 1, 93, 3, 93, 2112, 8, 93, 1, 93, 5, 93, 2115, 8, 93, 10, 93, 12, 93, 2118, 9, 93, 1, 93, 1, 93, 3, 93, 2122, 8, 93, 1, 93, 5, 93, 2125, 8, 93, 10, 93, 12, 93, 2128, 9, 93, 1, 93, 1, 93, 3, 93, 2132, 8, 93, 1, 93, 5, 93, 2135, 8, 93, 10, 93, 12, 93, 2138, 9, 93, 1, 93, 1, 93, 3, 93, 2142, 8, 93, 1, 93, 5, 93, 2145, 8, 93, 10, 93, 12, 93, 2148, 9, 93, 1, 93, 1, 93, 3, 93, 2152, 8, 93, 1, 93, 5, 93, 2155, 8, 93, 10, 93, 12, 93, 2158, 9, 93, 1, 93, 1, 93, 3, 93, 2162, 8, 93, 1, 93, 5, 93, 2165, 8, 93, 10, 93, 12, 93, 2168, 9, 93, 1, 93, 1, 93, 3, 93, 2172, 8, 93, 1, 93, 5, 93, 2175, 8, 93, 10, 93, 12, 93, 2178, 9, 93, 1, 93, 1, 93, 3, 93, 2182, 8, 93, 1, 93, 5, 93, 2185, 8, 93, 10, 93, 12, 93, 2188, 9, 93, 1, 93, 1, 93, 3, 93, 2192, 8, 93, 1, 93, 5, 93, 2195, 8, 93, 10, 93, 12, 93, 2198, 9, 93, 1, 93, 1, 93, 3, 93, 2202, 8, 93, 1, 93, 5, 93, 2205, 8, 93, 10, 93, 12, 93, 2208, 9, 93, 1, 93, 1, 93, 3, 93, 2212, 8, 93, 1, 93, 5, 93, 2215, 8, 93, 10, 93, 12, 93, 2218, 9, 93, 1, 93, 1, 93, 3, 93, 2222, 8, 93, 1, 93, 5, 93, 2225, 8, 93, 10, 93, 12, 93, 2228, 9, 93, 1, 93, 1, 93, 3, 93, 2232, 8, 93, 1, 93, 5, 93, 2235, 8, 93, 10, 93, 12, 93, 2238, 9, 93, 1, 93, 1, 93, 3, 93, 2242, 8, 93, 1, 93, 5, 93, 2245, 8, 93, 10, 93, 12, 93, 2248, 9, 93, 1, 93, 1, 93, 3, 93, 2252, 8, 93, 1, 93, 5, 93, 2255, 8, 93, 10, 93, 12, 93, 2258, 9, 93, 1, 93, 1, 93, 3, 93, 2262, 8, 93, 1, 93, 5, 93, 2265, 8, 93, 10, 93, 12, 93, 2268, 9, 93, 1, 93, 1, 93, 3, 93, 2272, 8, 93, 1, 93, 5, 93, 2275, 8, 93, 10, 93, 12, 93, 2278, 9, 93, 1, 93, 1, 93, 3, 93, 2282, 8, 93, 1, 93, 5, 93, 2285, 8, 93, 10, 93, 12, 93, 2288, 9, 93, 1, 93, 1, 93, 3, 93, 2292, 8, 93, 1, 93, 5, 93, 2295, 8, 93, 10, 93, 12, 93, 2298, 9, 93, 1, 93, 1, 93, 3, 93, 2302, 8, 93, 1, 93, 5, 93, 2305, 8, 93, 10, 93, 12, 93, 2308, 9, 93, 1, 93, 1, 93, 3, 93, 2312, 8, 93, 1, 93, 5, 93, 2315, 8, 93, 10, 93, 12, 93, 2318, 9, 93, 1, 93, 1, 93, 3, 93, 2322, 8, 93, 1, 93, 5, 93, 2325, 8, 93, 10, 93, 12, 93, 2328, 9, 93, 1, 93, 1, 93, 3, 93, 2332, 8, 93, 1, 93, 5, 93, 2335, 8, 93, 10, 93, 12, 93, 2338, 9, 93, 1, 93, 1, 93, 3, 93, 2342, 8, 93, 1, 93, 5, 93, 2345, 8, 93, 10, 93, 12, 93, 2348, 9, 93, 1, 93, 1, 93, 3, 93, 2352, 8, 93, 1, 93, 5, 93, 2355, 8, 93, 10, 93, 12, 93, 2358, 9, 93, 1, 93, 1, 93, 3, 93, 2362, 8, 93, 1, 93, 5, 93, 2365, 8, 93, 10, 93, 12, 93, 2368, 9, 93, 1, 93, 1, 93, 3, 93, 2372, 8, 93, 3, 93, 2374, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2381, 8, 94, 1, 95, 1, 95, 1, 95, 3, 95, 2386, 8, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 3, 96, 2393, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2399, 8, 96, 1, 96, 3, 96, 2402, 8, 96, 1, 96, 3, 96, 2405, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2411, 8, 97, 1, 97, 3, 97, 2414, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 2420, 8, 98, 4, 98, 2422, 8, 98, 11, 98, 12, 98, 2423, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2430, 8, 99, 1, 99, 3, 99, 2433, 8, 99, 1, 99, 3, 99, 2436, 8, 99, 1, 100, 1, 100, 1, 100, 3, 100, 2441, 8, 100, 1, 101, 1, 101, 1, 101, 3, 101, 2446, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2455, 8, 102, 3, 102, 2457, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 5, 102, 2463, 8, 102, 10, 102, 12, 102, 2466, 9, 102, 3, 102, 2468, 8, 102, 1, 102, 1, 102, 3, 102, 2472, 8, 102, 1, 102, 1, 102, 3, 102, 2476, 8, 102, 1, 102, 3, 102, 2479, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2488, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2510, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2521, 8, 105, 10, 105, 12, 105, 2524, 9, 105, 1, 105, 1, 105, 3, 105, 2528, 8, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2538, 8, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 3, 107, 2548, 8, 107, 1, 107, 1, 107, 1, 107, 3, 107, 2553, 8, 107, 1, 108, 1, 108, 1, 109, 1, 109, 1, 110, 1, 110, 3, 110, 2561, 8, 110, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 3, 112, 2568, 8, 112, 1, 112, 1, 112, 3, 112, 2572, 8, 112, 1, 112, 1, 112, 3, 112, 2576, 8, 112, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 5, 114, 2585, 8, 114, 10, 114, 12, 114, 2588, 9, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2594, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 117, 1, 117, 1, 118, 1, 118, 3, 118, 2608, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2615, 8, 118, 1, 118, 1, 118, 3, 118, 2619, 8, 118, 1, 119, 1, 119, 3, 119, 2623, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2631, 8, 119, 1, 119, 1, 119, 3, 119, 2635, 8, 119, 1, 120, 1, 120, 3, 120, 2639, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2649, 8, 120, 3, 120, 2651, 8, 120, 1, 120, 1, 120, 3, 120, 2655, 8, 120, 1, 120, 3, 120, 2658, 8, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2663, 8, 120, 1, 120, 3, 120, 2666, 8, 120, 1, 120, 3, 120, 2669, 8, 120, 1, 121, 1, 121, 3, 121, 2673, 8, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2681, 8, 121, 1, 121, 1, 121, 3, 121, 2685, 8, 121, 1, 122, 1, 122, 1, 122, 5, 122, 2690, 8, 122, 10, 122, 12, 122, 2693, 9, 122, 1, 123, 1, 123, 3, 123, 2697, 8, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2707, 8, 124, 1, 124, 3, 124, 2710, 8, 124, 1, 124, 1, 124, 3, 124, 2714, 8, 124, 1, 124, 1, 124, 3, 124, 2718, 8, 124, 1, 125, 1, 125, 1, 125, 5, 125, 2723, 8, 125, 10, 125, 12, 125, 2726, 9, 125, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2732, 8, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2738, 8, 126, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2752, 8, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2759, 8, 129, 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, 131, 3, 131, 2774, 8, 131, 1, 132, 1, 132, 3, 132, 2778, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2785, 8, 132, 1, 132, 5, 132, 2788, 8, 132, 10, 132, 12, 132, 2791, 9, 132, 1, 132, 3, 132, 2794, 8, 132, 1, 132, 3, 132, 2797, 8, 132, 1, 132, 3, 132, 2800, 8, 132, 1, 132, 1, 132, 3, 132, 2804, 8, 132, 1, 133, 1, 133, 1, 134, 1, 134, 3, 134, 2810, 8, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 3, 138, 2828, 8, 138, 1, 138, 1, 138, 1, 138, 3, 138, 2833, 8, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 2841, 8, 138, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 2860, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 2925, 8, 142, 1, 143, 1, 143, 1, 143, 5, 143, 2930, 8, 143, 10, 143, 12, 143, 2933, 9, 143, 1, 144, 1, 144, 3, 144, 2937, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 2967, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 5, 150, 2988, 8, 150, 10, 150, 12, 150, 2991, 9, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3001, 8, 152, 1, 153, 1, 153, 1, 153, 5, 153, 3006, 8, 153, 10, 153, 12, 153, 3009, 9, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 3, 156, 3025, 8, 156, 1, 156, 3, 156, 3028, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 4, 157, 3035, 8, 157, 11, 157, 12, 157, 3036, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 5, 159, 3045, 8, 159, 10, 159, 12, 159, 3048, 9, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 5, 161, 3057, 8, 161, 10, 161, 12, 161, 3060, 9, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 5, 163, 3069, 8, 163, 10, 163, 12, 163, 3072, 9, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 3, 165, 3082, 8, 165, 1, 165, 3, 165, 3085, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 5, 168, 3096, 8, 168, 10, 168, 12, 168, 3099, 9, 168, 1, 169, 1, 169, 1, 169, 5, 169, 3104, 8, 169, 10, 169, 12, 169, 3107, 9, 169, 1, 170, 1, 170, 1, 170, 3, 170, 3112, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 3118, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 3126, 8, 172, 1, 173, 1, 173, 1, 173, 5, 173, 3131, 8, 173, 10, 173, 12, 173, 3134, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 3141, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 3148, 8, 175, 1, 176, 1, 176, 1, 176, 5, 176, 3153, 8, 176, 10, 176, 12, 176, 3156, 9, 176, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3165, 8, 178, 10, 178, 12, 178, 3168, 9, 178, 3, 178, 3170, 8, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 5, 180, 3180, 8, 180, 10, 180, 12, 180, 3183, 9, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3206, 8, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3214, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 3220, 8, 182, 10, 182, 12, 182, 3223, 9, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 3242, 8, 183, 1, 184, 1, 184, 5, 184, 3246, 8, 184, 10, 184, 12, 184, 3249, 9, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 3, 185, 3256, 8, 185, 1, 186, 1, 186, 1, 186, 3, 186, 3261, 8, 186, 1, 186, 3, 186, 3264, 8, 186, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 5, 188, 3272, 8, 188, 10, 188, 12, 188, 3275, 9, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 3354, 8, 189, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 5, 191, 3362, 8, 191, 10, 191, 12, 191, 3365, 9, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 3, 192, 3372, 8, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 5, 192, 3380, 8, 192, 10, 192, 12, 192, 3383, 9, 192, 1, 192, 3, 192, 3386, 8, 192, 3, 192, 3388, 8, 192, 1, 192, 1, 192, 1, 192, 1, 192, 5, 192, 3394, 8, 192, 10, 192, 12, 192, 3397, 9, 192, 3, 192, 3399, 8, 192, 1, 192, 1, 192, 1, 192, 3, 192, 3404, 8, 192, 1, 192, 1, 192, 1, 192, 3, 192, 3409, 8, 192, 1, 192, 1, 192, 1, 192, 1, 192, 3, 192, 3415, 8, 192, 1, 193, 1, 193, 3, 193, 3419, 8, 193, 1, 193, 1, 193, 3, 193, 3423, 8, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3429, 8, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3435, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3440, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3445, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3450, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3455, 8, 193, 1, 194, 1, 194, 1, 194, 1, 194, 5, 194, 3461, 8, 194, 10, 194, 12, 194, 3464, 9, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 3474, 8, 195, 1, 196, 1, 196, 1, 196, 3, 196, 3479, 8, 196, 1, 196, 1, 196, 1, 196, 1, 196, 3, 196, 3485, 8, 196, 5, 196, 3487, 8, 196, 10, 196, 12, 196, 3490, 9, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 3498, 8, 197, 3, 197, 3500, 8, 197, 3, 197, 3502, 8, 197, 1, 198, 1, 198, 1, 198, 1, 198, 5, 198, 3508, 8, 198, 10, 198, 12, 198, 3511, 9, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, 1, 201, 1, 202, 1, 202, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 5, 204, 3544, 8, 204, 10, 204, 12, 204, 3547, 9, 204, 3, 204, 3549, 8, 204, 1, 204, 3, 204, 3552, 8, 204, 1, 205, 1, 205, 1, 205, 1, 205, 5, 205, 3558, 8, 205, 10, 205, 12, 205, 3561, 9, 205, 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 3567, 8, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 3578, 8, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 3, 208, 3587, 8, 208, 1, 208, 1, 208, 5, 208, 3591, 8, 208, 10, 208, 12, 208, 3594, 9, 208, 1, 208, 1, 208, 1, 209, 4, 209, 3599, 8, 209, 11, 209, 12, 209, 3600, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 3610, 8, 211, 1, 212, 1, 212, 1, 212, 1, 212, 4, 212, 3616, 8, 212, 11, 212, 12, 212, 3617, 1, 212, 1, 212, 5, 212, 3622, 8, 212, 10, 212, 12, 212, 3625, 9, 212, 1, 212, 3, 212, 3628, 8, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 3637, 8, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 3649, 8, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 3655, 8, 213, 3, 213, 3657, 8, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 3670, 8, 214, 5, 214, 3672, 8, 214, 10, 214, 12, 214, 3675, 9, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 5, 214, 3684, 8, 214, 10, 214, 12, 214, 3687, 9, 214, 1, 214, 1, 214, 3, 214, 3691, 8, 214, 3, 214, 3693, 8, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 3708, 8, 216, 1, 217, 4, 217, 3711, 8, 217, 11, 217, 12, 217, 3712, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 5, 219, 3724, 8, 219, 10, 219, 12, 219, 3727, 9, 219, 1, 219, 1, 219, 1, 220, 4, 220, 3732, 8, 220, 11, 220, 12, 220, 3733, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 3745, 8, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 3755, 8, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 3764, 8, 223, 1, 224, 1, 224, 1, 225, 4, 225, 3769, 8, 225, 11, 225, 12, 225, 3770, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 3781, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 3792, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 5, 230, 3809, 8, 230, 10, 230, 12, 230, 3812, 9, 230, 1, 230, 1, 230, 3, 230, 3816, 8, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 5, 231, 3825, 8, 231, 10, 231, 12, 231, 3828, 9, 231, 1, 231, 1, 231, 3, 231, 3832, 8, 231, 1, 231, 1, 231, 5, 231, 3836, 8, 231, 10, 231, 12, 231, 3839, 9, 231, 1, 231, 3, 231, 3842, 8, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 3, 232, 3850, 8, 232, 1, 232, 3, 232, 3853, 8, 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, 5, 235, 3867, 8, 235, 10, 235, 12, 235, 3870, 9, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 3, 236, 3877, 8, 236, 1, 236, 3, 236, 3880, 8, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 3, 237, 3887, 8, 237, 1, 237, 1, 237, 1, 237, 1, 237, 5, 237, 3893, 8, 237, 10, 237, 12, 237, 3896, 9, 237, 1, 237, 1, 237, 3, 237, 3900, 8, 237, 1, 237, 3, 237, 3903, 8, 237, 1, 237, 3, 237, 3906, 8, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 5, 238, 3914, 8, 238, 10, 238, 12, 238, 3917, 9, 238, 3, 238, 3919, 8, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 3, 239, 3926, 8, 239, 1, 239, 3, 239, 3929, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 5, 240, 3935, 8, 240, 10, 240, 12, 240, 3938, 9, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 5, 241, 3953, 8, 241, 10, 241, 12, 241, 3956, 9, 241, 1, 241, 1, 241, 1, 241, 3, 241, 3961, 8, 241, 1, 241, 3, 241, 3964, 8, 241, 1, 242, 1, 242, 1, 242, 3, 242, 3969, 8, 242, 1, 242, 5, 242, 3972, 8, 242, 10, 242, 12, 242, 3975, 9, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 5, 243, 3982, 8, 243, 10, 243, 12, 243, 3985, 9, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 5, 245, 4001, 8, 245, 10, 245, 12, 245, 4004, 9, 245, 1, 245, 1, 245, 1, 245, 4, 245, 4009, 8, 245, 11, 245, 12, 245, 4010, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 5, 246, 4021, 8, 246, 10, 246, 12, 246, 4024, 9, 246, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 4030, 8, 246, 1, 246, 1, 246, 3, 246, 4034, 8, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 3, 248, 4048, 8, 248, 1, 248, 1, 248, 3, 248, 4052, 8, 248, 1, 248, 1, 248, 3, 248, 4056, 8, 248, 1, 248, 1, 248, 1, 248, 3, 248, 4061, 8, 248, 1, 248, 1, 248, 1, 248, 3, 248, 4066, 8, 248, 1, 248, 1, 248, 1, 248, 3, 248, 4071, 8, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 3, 248, 4078, 8, 248, 1, 248, 3, 248, 4081, 8, 248, 1, 249, 5, 249, 4084, 8, 249, 10, 249, 12, 249, 4087, 9, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 4116, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4124, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4129, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4134, 8, 251, 1, 251, 1, 251, 3, 251, 4138, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4143, 8, 251, 1, 251, 1, 251, 3, 251, 4147, 8, 251, 1, 251, 1, 251, 4, 251, 4151, 8, 251, 11, 251, 12, 251, 4152, 3, 251, 4155, 8, 251, 1, 251, 1, 251, 1, 251, 4, 251, 4160, 8, 251, 11, 251, 12, 251, 4161, 3, 251, 4164, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4173, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4178, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4183, 8, 251, 1, 251, 1, 251, 3, 251, 4187, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4192, 8, 251, 1, 251, 1, 251, 3, 251, 4196, 8, 251, 1, 251, 1, 251, 4, 251, 4200, 8, 251, 11, 251, 12, 251, 4201, 3, 251, 4204, 8, 251, 1, 251, 1, 251, 1, 251, 4, 251, 4209, 8, 251, 11, 251, 12, 251, 4210, 3, 251, 4213, 8, 251, 3, 251, 4215, 8, 251, 1, 252, 1, 252, 1, 252, 3, 252, 4220, 8, 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4226, 8, 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4232, 8, 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4238, 8, 252, 1, 252, 1, 252, 3, 252, 4242, 8, 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4248, 8, 252, 3, 252, 4250, 8, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 3, 254, 4262, 8, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 5, 254, 4269, 8, 254, 10, 254, 12, 254, 4272, 9, 254, 1, 254, 1, 254, 3, 254, 4276, 8, 254, 1, 254, 1, 254, 4, 254, 4280, 8, 254, 11, 254, 12, 254, 4281, 3, 254, 4284, 8, 254, 1, 254, 1, 254, 1, 254, 4, 254, 4289, 8, 254, 11, 254, 12, 254, 4290, 3, 254, 4293, 8, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 3, 256, 4304, 8, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 5, 256, 4311, 8, 256, 10, 256, 12, 256, 4314, 9, 256, 1, 256, 1, 256, 3, 256, 4318, 8, 256, 1, 257, 1, 257, 3, 257, 4322, 8, 257, 1, 257, 1, 257, 3, 257, 4326, 8, 257, 1, 257, 1, 257, 4, 257, 4330, 8, 257, 11, 257, 12, 257, 4331, 3, 257, 4334, 8, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 4346, 8, 259, 1, 259, 4, 259, 4349, 8, 259, 11, 259, 12, 259, 4350, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 4364, 8, 261, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 4370, 8, 262, 1, 262, 1, 262, 3, 262, 4374, 8, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 3, 263, 4381, 8, 263, 1, 263, 1, 263, 1, 263, 4, 263, 4386, 8, 263, 11, 263, 12, 263, 4387, 3, 263, 4390, 8, 263, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 5, 265, 4399, 8, 265, 10, 265, 12, 265, 4402, 9, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 3, 265, 4411, 8, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 5, 265, 4418, 8, 265, 10, 265, 12, 265, 4421, 9, 265, 3, 265, 4423, 8, 265, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 3, 268, 4435, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 4441, 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4450, 8, 270, 3, 270, 4452, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4459, 8, 270, 3, 270, 4461, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4468, 8, 270, 3, 270, 4470, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4477, 8, 270, 3, 270, 4479, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4486, 8, 270, 3, 270, 4488, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4495, 8, 270, 3, 270, 4497, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4504, 8, 270, 3, 270, 4506, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4513, 8, 270, 3, 270, 4515, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4522, 8, 270, 3, 270, 4524, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4531, 8, 270, 3, 270, 4533, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4540, 8, 270, 3, 270, 4542, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4550, 8, 270, 3, 270, 4552, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4580, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4587, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4603, 8, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4608, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4619, 8, 270, 3, 270, 4621, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4654, 8, 270, 3, 270, 4656, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4664, 8, 270, 3, 270, 4666, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4674, 8, 270, 3, 270, 4676, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4684, 8, 270, 3, 270, 4686, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4695, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4705, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4711, 8, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4716, 8, 270, 3, 270, 4718, 8, 270, 1, 270, 3, 270, 4721, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4730, 8, 270, 3, 270, 4732, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4741, 8, 270, 3, 270, 4743, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4751, 8, 270, 3, 270, 4753, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4765, 8, 270, 3, 270, 4767, 8, 270, 3, 270, 4769, 8, 270, 1, 271, 1, 271, 1, 271, 1, 271, 5, 271, 4775, 8, 271, 10, 271, 12, 271, 4778, 9, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4783, 8, 271, 3, 271, 4785, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4790, 8, 271, 3, 271, 4792, 8, 271, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 4802, 8, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, 4812, 8, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 4853, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 4883, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 4892, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 4928, 8, 276, 1, 277, 1, 277, 3, 277, 4932, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 4940, 8, 277, 1, 277, 3, 277, 4943, 8, 277, 1, 277, 5, 277, 4946, 8, 277, 10, 277, 12, 277, 4949, 9, 277, 1, 277, 1, 277, 3, 277, 4953, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 4959, 8, 277, 3, 277, 4961, 8, 277, 1, 277, 1, 277, 3, 277, 4965, 8, 277, 1, 277, 1, 277, 3, 277, 4969, 8, 277, 1, 277, 1, 277, 3, 277, 4973, 8, 277, 1, 278, 3, 278, 4976, 8, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 4983, 8, 278, 1, 278, 3, 278, 4986, 8, 278, 1, 278, 1, 278, 3, 278, 4990, 8, 278, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 3, 280, 4997, 8, 280, 1, 280, 5, 280, 5000, 8, 280, 10, 280, 12, 280, 5003, 9, 280, 1, 281, 1, 281, 3, 281, 5007, 8, 281, 1, 281, 3, 281, 5010, 8, 281, 1, 281, 3, 281, 5013, 8, 281, 1, 281, 3, 281, 5016, 8, 281, 1, 281, 3, 281, 5019, 8, 281, 1, 281, 3, 281, 5022, 8, 281, 1, 281, 1, 281, 3, 281, 5026, 8, 281, 1, 281, 3, 281, 5029, 8, 281, 1, 281, 3, 281, 5032, 8, 281, 1, 281, 1, 281, 3, 281, 5036, 8, 281, 1, 281, 3, 281, 5039, 8, 281, 3, 281, 5041, 8, 281, 1, 282, 1, 282, 3, 282, 5045, 8, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 283, 5, 283, 5053, 8, 283, 10, 283, 12, 283, 5056, 9, 283, 3, 283, 5058, 8, 283, 1, 284, 1, 284, 1, 284, 3, 284, 5063, 8, 284, 1, 284, 1, 284, 1, 284, 3, 284, 5068, 8, 284, 3, 284, 5070, 8, 284, 1, 285, 1, 285, 3, 285, 5074, 8, 285, 1, 286, 1, 286, 1, 286, 5, 286, 5079, 8, 286, 10, 286, 12, 286, 5082, 9, 286, 1, 287, 1, 287, 3, 287, 5086, 8, 287, 1, 287, 3, 287, 5089, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 5095, 8, 287, 1, 287, 3, 287, 5098, 8, 287, 3, 287, 5100, 8, 287, 1, 288, 3, 288, 5103, 8, 288, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 5109, 8, 288, 1, 288, 3, 288, 5112, 8, 288, 1, 288, 1, 288, 1, 288, 3, 288, 5117, 8, 288, 1, 288, 3, 288, 5120, 8, 288, 3, 288, 5122, 8, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, 5134, 8, 289, 1, 290, 1, 290, 3, 290, 5138, 8, 290, 1, 290, 1, 290, 3, 290, 5142, 8, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5147, 8, 290, 1, 290, 3, 290, 5150, 8, 290, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 5, 295, 5167, 8, 295, 10, 295, 12, 295, 5170, 9, 295, 1, 296, 1, 296, 3, 296, 5174, 8, 296, 1, 297, 1, 297, 1, 297, 5, 297, 5179, 8, 297, 10, 297, 12, 297, 5182, 9, 297, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 5188, 8, 298, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 5194, 8, 298, 3, 298, 5196, 8, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, 5214, 8, 299, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 5225, 8, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 5240, 8, 301, 3, 301, 5242, 8, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 5250, 8, 303, 1, 303, 3, 303, 5253, 8, 303, 1, 303, 3, 303, 5256, 8, 303, 1, 303, 3, 303, 5259, 8, 303, 1, 303, 3, 303, 5262, 8, 303, 1, 304, 1, 304, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 3, 308, 5278, 8, 308, 1, 308, 1, 308, 3, 308, 5282, 8, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5287, 8, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 5295, 8, 309, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 5303, 8, 311, 1, 312, 1, 312, 1, 312, 5, 312, 5308, 8, 312, 10, 312, 12, 312, 5311, 9, 312, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 5, 316, 5351, 8, 316, 10, 316, 12, 316, 5354, 9, 316, 1, 316, 1, 316, 3, 316, 5358, 8, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 5, 316, 5365, 8, 316, 10, 316, 12, 316, 5368, 9, 316, 1, 316, 1, 316, 3, 316, 5372, 8, 316, 1, 316, 3, 316, 5375, 8, 316, 1, 316, 1, 316, 1, 316, 3, 316, 5380, 8, 316, 1, 317, 4, 317, 5383, 8, 317, 11, 317, 12, 317, 5384, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 5, 318, 5399, 8, 318, 10, 318, 12, 318, 5402, 9, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 5, 318, 5410, 8, 318, 10, 318, 12, 318, 5413, 9, 318, 1, 318, 1, 318, 3, 318, 5417, 8, 318, 1, 318, 1, 318, 3, 318, 5421, 8, 318, 1, 318, 1, 318, 3, 318, 5425, 8, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 5441, 8, 320, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 5, 324, 5458, 8, 324, 10, 324, 12, 324, 5461, 9, 324, 1, 325, 1, 325, 1, 325, 5, 325, 5466, 8, 325, 10, 325, 12, 325, 5469, 9, 325, 1, 326, 3, 326, 5472, 8, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 5486, 8, 327, 1, 327, 1, 327, 1, 327, 3, 327, 5491, 8, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 5499, 8, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 5505, 8, 327, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 5, 329, 5512, 8, 329, 10, 329, 12, 329, 5515, 9, 329, 1, 330, 1, 330, 1, 330, 5, 330, 5520, 8, 330, 10, 330, 12, 330, 5523, 9, 330, 1, 331, 3, 331, 5526, 8, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 3, 332, 5550, 8, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 4, 333, 5558, 8, 333, 11, 333, 12, 333, 5559, 1, 333, 1, 333, 3, 333, 5564, 8, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 3, 336, 5580, 8, 336, 1, 336, 1, 336, 3, 336, 5584, 8, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 3, 337, 5591, 8, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 5, 339, 5600, 8, 339, 10, 339, 12, 339, 5603, 9, 339, 1, 340, 1, 340, 1, 340, 1, 340, 5, 340, 5609, 8, 340, 10, 340, 12, 340, 5612, 9, 340, 1, 340, 1, 340, 1, 340, 3, 340, 5617, 8, 340, 1, 341, 1, 341, 1, 341, 5, 341, 5622, 8, 341, 10, 341, 12, 341, 5625, 9, 341, 1, 342, 1, 342, 1, 342, 5, 342, 5630, 8, 342, 10, 342, 12, 342, 5633, 9, 342, 1, 343, 1, 343, 1, 343, 3, 343, 5638, 8, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 3, 344, 5645, 8, 344, 1, 345, 1, 345, 1, 345, 1, 345, 5, 345, 5651, 8, 345, 10, 345, 12, 345, 5654, 9, 345, 3, 345, 5656, 8, 345, 1, 345, 1, 345, 1, 346, 1, 346, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 3, 348, 5671, 8, 348, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 5, 350, 5678, 8, 350, 10, 350, 12, 350, 5681, 9, 350, 1, 351, 1, 351, 1, 351, 1, 351, 3, 351, 5687, 8, 351, 1, 352, 1, 352, 1, 352, 3, 352, 5692, 8, 352, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 0, 0, 355, 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, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 0, 48, 2, 0, 22, 22, 415, 415, 1, 0, 33, 34, 2, 0, 30, 30, 33, 33, 2, 0, 435, 436, 467, 467, 2, 0, 92, 92, 467, 467, 2, 0, 391, 391, 419, 419, 1, 0, 93, 94, 2, 0, 12, 12, 43, 43, 2, 0, 290, 290, 410, 410, 2, 0, 39, 39, 51, 51, 2, 0, 14, 16, 53, 54, 2, 0, 478, 478, 484, 484, 3, 0, 68, 68, 133, 136, 297, 297, 2, 0, 99, 99, 327, 330, 2, 0, 499, 499, 503, 503, 1, 0, 502, 503, 1, 0, 280, 281, 6, 0, 280, 282, 469, 474, 478, 478, 482, 486, 489, 490, 498, 502, 4, 0, 126, 126, 282, 282, 291, 292, 503, 504, 10, 0, 39, 39, 146, 155, 158, 160, 162, 163, 165, 165, 167, 174, 178, 183, 192, 193, 222, 226, 246, 246, 3, 0, 126, 126, 138, 138, 503, 503, 3, 0, 250, 256, 391, 391, 503, 503, 4, 0, 133, 134, 241, 245, 290, 290, 503, 503, 2, 0, 213, 213, 501, 501, 1, 0, 407, 409, 1, 0, 499, 500, 4, 0, 193, 193, 318, 318, 320, 320, 345, 345, 2, 0, 334, 334, 427, 427, 2, 0, 331, 331, 503, 503, 2, 0, 290, 292, 499, 499, 2, 0, 373, 373, 503, 503, 7, 0, 146, 152, 158, 160, 163, 163, 167, 174, 192, 193, 222, 226, 503, 503, 2, 0, 286, 286, 472, 472, 1, 0, 83, 84, 8, 0, 141, 143, 185, 185, 190, 190, 220, 220, 309, 309, 368, 369, 371, 374, 503, 503, 2, 0, 323, 323, 391, 392, 1, 0, 503, 504, 2, 1, 478, 478, 482, 482, 1, 0, 469, 474, 1, 0, 475, 476, 2, 0, 477, 481, 491, 491, 1, 0, 257, 262, 1, 0, 271, 275, 7, 0, 121, 121, 126, 126, 138, 138, 183, 183, 271, 277, 291, 292, 503, 504, 1, 0, 291, 292, 6, 0, 48, 48, 186, 187, 215, 215, 296, 296, 394, 394, 503, 503, 37, 0, 41, 43, 48, 48, 50, 51, 53, 53, 68, 68, 114, 114, 122, 122, 133, 134, 136, 136, 162, 162, 166, 166, 186, 186, 189, 191, 194, 194, 203, 204, 211, 212, 214, 215, 218, 218, 227, 227, 242, 242, 271, 275, 297, 297, 299, 299, 325, 326, 341, 342, 362, 362, 365, 365, 385, 385, 391, 391, 393, 393, 405, 410, 418, 418, 431, 431, 435, 436, 441, 443, 465, 465, 467, 467, 57, 0, 8, 9, 17, 21, 23, 30, 32, 35, 38, 43, 47, 48, 50, 51, 53, 53, 55, 58, 64, 66, 68, 75, 80, 89, 92, 92, 95, 100, 102, 105, 109, 109, 111, 116, 118, 118, 122, 122, 130, 130, 133, 134, 136, 137, 139, 144, 146, 151, 154, 164, 166, 170, 172, 173, 177, 177, 185, 186, 189, 194, 203, 212, 214, 215, 217, 218, 222, 227, 240, 243, 246, 246, 257, 265, 271, 275, 280, 286, 289, 297, 299, 302, 306, 321, 323, 326, 331, 357, 359, 375, 377, 389, 391, 391, 393, 393, 395, 396, 398, 416, 418, 418, 420, 420, 423, 423, 425, 456, 462, 465, 467, 468, 480, 481, 6437, 0, 713, 1, 0, 0, 0, 2, 719, 1, 0, 0, 0, 4, 739, 1, 0, 0, 0, 6, 741, 1, 0, 0, 0, 8, 773, 1, 0, 0, 0, 10, 903, 1, 0, 0, 0, 12, 917, 1, 0, 0, 0, 14, 934, 1, 0, 0, 0, 16, 952, 1, 0, 0, 0, 18, 975, 1, 0, 0, 0, 20, 984, 1, 0, 0, 0, 22, 1000, 1, 0, 0, 0, 24, 1002, 1, 0, 0, 0, 26, 1012, 1, 0, 0, 0, 28, 1042, 1, 0, 0, 0, 30, 1069, 1, 0, 0, 0, 32, 1127, 1, 0, 0, 0, 34, 1140, 1, 0, 0, 0, 36, 1189, 1, 0, 0, 0, 38, 1210, 1, 0, 0, 0, 40, 1212, 1, 0, 0, 0, 42, 1220, 1, 0, 0, 0, 44, 1225, 1, 0, 0, 0, 46, 1259, 1, 0, 0, 0, 48, 1261, 1, 0, 0, 0, 50, 1266, 1, 0, 0, 0, 52, 1277, 1, 0, 0, 0, 54, 1282, 1, 0, 0, 0, 56, 1290, 1, 0, 0, 0, 58, 1298, 1, 0, 0, 0, 60, 1306, 1, 0, 0, 0, 62, 1314, 1, 0, 0, 0, 64, 1322, 1, 0, 0, 0, 66, 1330, 1, 0, 0, 0, 68, 1339, 1, 0, 0, 0, 70, 1359, 1, 0, 0, 0, 72, 1361, 1, 0, 0, 0, 74, 1382, 1, 0, 0, 0, 76, 1387, 1, 0, 0, 0, 78, 1393, 1, 0, 0, 0, 80, 1401, 1, 0, 0, 0, 82, 1437, 1, 0, 0, 0, 84, 1485, 1, 0, 0, 0, 86, 1491, 1, 0, 0, 0, 88, 1502, 1, 0, 0, 0, 90, 1504, 1, 0, 0, 0, 92, 1518, 1, 0, 0, 0, 94, 1520, 1, 0, 0, 0, 96, 1529, 1, 0, 0, 0, 98, 1549, 1, 0, 0, 0, 100, 1584, 1, 0, 0, 0, 102, 1622, 1, 0, 0, 0, 104, 1624, 1, 0, 0, 0, 106, 1651, 1, 0, 0, 0, 108, 1654, 1, 0, 0, 0, 110, 1660, 1, 0, 0, 0, 112, 1668, 1, 0, 0, 0, 114, 1675, 1, 0, 0, 0, 116, 1677, 1, 0, 0, 0, 118, 1687, 1, 0, 0, 0, 120, 1701, 1, 0, 0, 0, 122, 1703, 1, 0, 0, 0, 124, 1761, 1, 0, 0, 0, 126, 1775, 1, 0, 0, 0, 128, 1795, 1, 0, 0, 0, 130, 1810, 1, 0, 0, 0, 132, 1812, 1, 0, 0, 0, 134, 1818, 1, 0, 0, 0, 136, 1826, 1, 0, 0, 0, 138, 1828, 1, 0, 0, 0, 140, 1836, 1, 0, 0, 0, 142, 1845, 1, 0, 0, 0, 144, 1869, 1, 0, 0, 0, 146, 1872, 1, 0, 0, 0, 148, 1876, 1, 0, 0, 0, 150, 1879, 1, 0, 0, 0, 152, 1913, 1, 0, 0, 0, 154, 1928, 1, 0, 0, 0, 156, 1930, 1, 0, 0, 0, 158, 1938, 1, 0, 0, 0, 160, 1946, 1, 0, 0, 0, 162, 1968, 1, 0, 0, 0, 164, 1987, 1, 0, 0, 0, 166, 1995, 1, 0, 0, 0, 168, 2001, 1, 0, 0, 0, 170, 2004, 1, 0, 0, 0, 172, 2010, 1, 0, 0, 0, 174, 2020, 1, 0, 0, 0, 176, 2028, 1, 0, 0, 0, 178, 2030, 1, 0, 0, 0, 180, 2037, 1, 0, 0, 0, 182, 2045, 1, 0, 0, 0, 184, 2050, 1, 0, 0, 0, 186, 2373, 1, 0, 0, 0, 188, 2375, 1, 0, 0, 0, 190, 2382, 1, 0, 0, 0, 192, 2392, 1, 0, 0, 0, 194, 2406, 1, 0, 0, 0, 196, 2415, 1, 0, 0, 0, 198, 2425, 1, 0, 0, 0, 200, 2437, 1, 0, 0, 0, 202, 2442, 1, 0, 0, 0, 204, 2447, 1, 0, 0, 0, 206, 2487, 1, 0, 0, 0, 208, 2509, 1, 0, 0, 0, 210, 2511, 1, 0, 0, 0, 212, 2532, 1, 0, 0, 0, 214, 2544, 1, 0, 0, 0, 216, 2554, 1, 0, 0, 0, 218, 2556, 1, 0, 0, 0, 220, 2558, 1, 0, 0, 0, 222, 2562, 1, 0, 0, 0, 224, 2565, 1, 0, 0, 0, 226, 2577, 1, 0, 0, 0, 228, 2593, 1, 0, 0, 0, 230, 2595, 1, 0, 0, 0, 232, 2601, 1, 0, 0, 0, 234, 2603, 1, 0, 0, 0, 236, 2607, 1, 0, 0, 0, 238, 2622, 1, 0, 0, 0, 240, 2638, 1, 0, 0, 0, 242, 2672, 1, 0, 0, 0, 244, 2686, 1, 0, 0, 0, 246, 2696, 1, 0, 0, 0, 248, 2701, 1, 0, 0, 0, 250, 2719, 1, 0, 0, 0, 252, 2737, 1, 0, 0, 0, 254, 2739, 1, 0, 0, 0, 256, 2742, 1, 0, 0, 0, 258, 2746, 1, 0, 0, 0, 260, 2760, 1, 0, 0, 0, 262, 2763, 1, 0, 0, 0, 264, 2777, 1, 0, 0, 0, 266, 2805, 1, 0, 0, 0, 268, 2809, 1, 0, 0, 0, 270, 2811, 1, 0, 0, 0, 272, 2813, 1, 0, 0, 0, 274, 2818, 1, 0, 0, 0, 276, 2840, 1, 0, 0, 0, 278, 2842, 1, 0, 0, 0, 280, 2859, 1, 0, 0, 0, 282, 2861, 1, 0, 0, 0, 284, 2924, 1, 0, 0, 0, 286, 2926, 1, 0, 0, 0, 288, 2934, 1, 0, 0, 0, 290, 2938, 1, 0, 0, 0, 292, 2966, 1, 0, 0, 0, 294, 2968, 1, 0, 0, 0, 296, 2974, 1, 0, 0, 0, 298, 2979, 1, 0, 0, 0, 300, 2984, 1, 0, 0, 0, 302, 2992, 1, 0, 0, 0, 304, 3000, 1, 0, 0, 0, 306, 3002, 1, 0, 0, 0, 308, 3010, 1, 0, 0, 0, 310, 3014, 1, 0, 0, 0, 312, 3021, 1, 0, 0, 0, 314, 3034, 1, 0, 0, 0, 316, 3038, 1, 0, 0, 0, 318, 3041, 1, 0, 0, 0, 320, 3049, 1, 0, 0, 0, 322, 3053, 1, 0, 0, 0, 324, 3061, 1, 0, 0, 0, 326, 3065, 1, 0, 0, 0, 328, 3073, 1, 0, 0, 0, 330, 3081, 1, 0, 0, 0, 332, 3086, 1, 0, 0, 0, 334, 3090, 1, 0, 0, 0, 336, 3092, 1, 0, 0, 0, 338, 3100, 1, 0, 0, 0, 340, 3111, 1, 0, 0, 0, 342, 3113, 1, 0, 0, 0, 344, 3125, 1, 0, 0, 0, 346, 3127, 1, 0, 0, 0, 348, 3135, 1, 0, 0, 0, 350, 3147, 1, 0, 0, 0, 352, 3149, 1, 0, 0, 0, 354, 3157, 1, 0, 0, 0, 356, 3159, 1, 0, 0, 0, 358, 3173, 1, 0, 0, 0, 360, 3175, 1, 0, 0, 0, 362, 3213, 1, 0, 0, 0, 364, 3215, 1, 0, 0, 0, 366, 3241, 1, 0, 0, 0, 368, 3247, 1, 0, 0, 0, 370, 3250, 1, 0, 0, 0, 372, 3257, 1, 0, 0, 0, 374, 3265, 1, 0, 0, 0, 376, 3267, 1, 0, 0, 0, 378, 3353, 1, 0, 0, 0, 380, 3355, 1, 0, 0, 0, 382, 3357, 1, 0, 0, 0, 384, 3414, 1, 0, 0, 0, 386, 3454, 1, 0, 0, 0, 388, 3456, 1, 0, 0, 0, 390, 3473, 1, 0, 0, 0, 392, 3478, 1, 0, 0, 0, 394, 3501, 1, 0, 0, 0, 396, 3503, 1, 0, 0, 0, 398, 3514, 1, 0, 0, 0, 400, 3520, 1, 0, 0, 0, 402, 3522, 1, 0, 0, 0, 404, 3524, 1, 0, 0, 0, 406, 3526, 1, 0, 0, 0, 408, 3551, 1, 0, 0, 0, 410, 3566, 1, 0, 0, 0, 412, 3577, 1, 0, 0, 0, 414, 3579, 1, 0, 0, 0, 416, 3583, 1, 0, 0, 0, 418, 3598, 1, 0, 0, 0, 420, 3602, 1, 0, 0, 0, 422, 3605, 1, 0, 0, 0, 424, 3611, 1, 0, 0, 0, 426, 3656, 1, 0, 0, 0, 428, 3658, 1, 0, 0, 0, 430, 3696, 1, 0, 0, 0, 432, 3700, 1, 0, 0, 0, 434, 3710, 1, 0, 0, 0, 436, 3714, 1, 0, 0, 0, 438, 3717, 1, 0, 0, 0, 440, 3731, 1, 0, 0, 0, 442, 3744, 1, 0, 0, 0, 444, 3754, 1, 0, 0, 0, 446, 3756, 1, 0, 0, 0, 448, 3765, 1, 0, 0, 0, 450, 3768, 1, 0, 0, 0, 452, 3780, 1, 0, 0, 0, 454, 3782, 1, 0, 0, 0, 456, 3786, 1, 0, 0, 0, 458, 3793, 1, 0, 0, 0, 460, 3801, 1, 0, 0, 0, 462, 3817, 1, 0, 0, 0, 464, 3852, 1, 0, 0, 0, 466, 3854, 1, 0, 0, 0, 468, 3858, 1, 0, 0, 0, 470, 3862, 1, 0, 0, 0, 472, 3879, 1, 0, 0, 0, 474, 3881, 1, 0, 0, 0, 476, 3907, 1, 0, 0, 0, 478, 3922, 1, 0, 0, 0, 480, 3930, 1, 0, 0, 0, 482, 3941, 1, 0, 0, 0, 484, 3965, 1, 0, 0, 0, 486, 3976, 1, 0, 0, 0, 488, 3988, 1, 0, 0, 0, 490, 3992, 1, 0, 0, 0, 492, 4014, 1, 0, 0, 0, 494, 4037, 1, 0, 0, 0, 496, 4041, 1, 0, 0, 0, 498, 4085, 1, 0, 0, 0, 500, 4115, 1, 0, 0, 0, 502, 4214, 1, 0, 0, 0, 504, 4249, 1, 0, 0, 0, 506, 4251, 1, 0, 0, 0, 508, 4256, 1, 0, 0, 0, 510, 4294, 1, 0, 0, 0, 512, 4298, 1, 0, 0, 0, 514, 4319, 1, 0, 0, 0, 516, 4335, 1, 0, 0, 0, 518, 4341, 1, 0, 0, 0, 520, 4352, 1, 0, 0, 0, 522, 4358, 1, 0, 0, 0, 524, 4365, 1, 0, 0, 0, 526, 4375, 1, 0, 0, 0, 528, 4391, 1, 0, 0, 0, 530, 4422, 1, 0, 0, 0, 532, 4424, 1, 0, 0, 0, 534, 4426, 1, 0, 0, 0, 536, 4434, 1, 0, 0, 0, 538, 4440, 1, 0, 0, 0, 540, 4768, 1, 0, 0, 0, 542, 4791, 1, 0, 0, 0, 544, 4793, 1, 0, 0, 0, 546, 4801, 1, 0, 0, 0, 548, 4803, 1, 0, 0, 0, 550, 4811, 1, 0, 0, 0, 552, 4927, 1, 0, 0, 0, 554, 4929, 1, 0, 0, 0, 556, 4975, 1, 0, 0, 0, 558, 4991, 1, 0, 0, 0, 560, 4993, 1, 0, 0, 0, 562, 5040, 1, 0, 0, 0, 564, 5042, 1, 0, 0, 0, 566, 5057, 1, 0, 0, 0, 568, 5069, 1, 0, 0, 0, 570, 5073, 1, 0, 0, 0, 572, 5075, 1, 0, 0, 0, 574, 5099, 1, 0, 0, 0, 576, 5121, 1, 0, 0, 0, 578, 5133, 1, 0, 0, 0, 580, 5149, 1, 0, 0, 0, 582, 5151, 1, 0, 0, 0, 584, 5154, 1, 0, 0, 0, 586, 5157, 1, 0, 0, 0, 588, 5160, 1, 0, 0, 0, 590, 5163, 1, 0, 0, 0, 592, 5171, 1, 0, 0, 0, 594, 5175, 1, 0, 0, 0, 596, 5195, 1, 0, 0, 0, 598, 5213, 1, 0, 0, 0, 600, 5215, 1, 0, 0, 0, 602, 5241, 1, 0, 0, 0, 604, 5243, 1, 0, 0, 0, 606, 5261, 1, 0, 0, 0, 608, 5263, 1, 0, 0, 0, 610, 5265, 1, 0, 0, 0, 612, 5267, 1, 0, 0, 0, 614, 5271, 1, 0, 0, 0, 616, 5286, 1, 0, 0, 0, 618, 5294, 1, 0, 0, 0, 620, 5296, 1, 0, 0, 0, 622, 5302, 1, 0, 0, 0, 624, 5304, 1, 0, 0, 0, 626, 5312, 1, 0, 0, 0, 628, 5314, 1, 0, 0, 0, 630, 5317, 1, 0, 0, 0, 632, 5379, 1, 0, 0, 0, 634, 5382, 1, 0, 0, 0, 636, 5386, 1, 0, 0, 0, 638, 5426, 1, 0, 0, 0, 640, 5440, 1, 0, 0, 0, 642, 5442, 1, 0, 0, 0, 644, 5444, 1, 0, 0, 0, 646, 5452, 1, 0, 0, 0, 648, 5454, 1, 0, 0, 0, 650, 5462, 1, 0, 0, 0, 652, 5471, 1, 0, 0, 0, 654, 5475, 1, 0, 0, 0, 656, 5506, 1, 0, 0, 0, 658, 5508, 1, 0, 0, 0, 660, 5516, 1, 0, 0, 0, 662, 5525, 1, 0, 0, 0, 664, 5549, 1, 0, 0, 0, 666, 5551, 1, 0, 0, 0, 668, 5567, 1, 0, 0, 0, 670, 5574, 1, 0, 0, 0, 672, 5576, 1, 0, 0, 0, 674, 5587, 1, 0, 0, 0, 676, 5594, 1, 0, 0, 0, 678, 5596, 1, 0, 0, 0, 680, 5616, 1, 0, 0, 0, 682, 5618, 1, 0, 0, 0, 684, 5626, 1, 0, 0, 0, 686, 5637, 1, 0, 0, 0, 688, 5644, 1, 0, 0, 0, 690, 5646, 1, 0, 0, 0, 692, 5659, 1, 0, 0, 0, 694, 5661, 1, 0, 0, 0, 696, 5663, 1, 0, 0, 0, 698, 5672, 1, 0, 0, 0, 700, 5674, 1, 0, 0, 0, 702, 5686, 1, 0, 0, 0, 704, 5691, 1, 0, 0, 0, 706, 5693, 1, 0, 0, 0, 708, 5695, 1, 0, 0, 0, 710, 712, 3, 2, 1, 0, 711, 710, 1, 0, 0, 0, 712, 715, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 713, 714, 1, 0, 0, 0, 714, 716, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 716, 717, 5, 0, 0, 1, 717, 1, 1, 0, 0, 0, 718, 720, 3, 694, 347, 0, 719, 718, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 724, 1, 0, 0, 0, 721, 725, 3, 4, 2, 0, 722, 725, 3, 538, 269, 0, 723, 725, 3, 598, 299, 0, 724, 721, 1, 0, 0, 0, 724, 722, 1, 0, 0, 0, 724, 723, 1, 0, 0, 0, 725, 727, 1, 0, 0, 0, 726, 728, 5, 482, 0, 0, 727, 726, 1, 0, 0, 0, 727, 728, 1, 0, 0, 0, 728, 730, 1, 0, 0, 0, 729, 731, 5, 478, 0, 0, 730, 729, 1, 0, 0, 0, 730, 731, 1, 0, 0, 0, 731, 3, 1, 0, 0, 0, 732, 740, 3, 8, 4, 0, 733, 740, 3, 10, 5, 0, 734, 740, 3, 32, 16, 0, 735, 740, 3, 34, 17, 0, 736, 740, 3, 36, 18, 0, 737, 740, 3, 6, 3, 0, 738, 740, 3, 38, 19, 0, 739, 732, 1, 0, 0, 0, 739, 733, 1, 0, 0, 0, 739, 734, 1, 0, 0, 0, 739, 735, 1, 0, 0, 0, 739, 736, 1, 0, 0, 0, 739, 737, 1, 0, 0, 0, 739, 738, 1, 0, 0, 0, 740, 5, 1, 0, 0, 0, 741, 742, 5, 383, 0, 0, 742, 743, 5, 185, 0, 0, 743, 744, 5, 47, 0, 0, 744, 749, 3, 548, 274, 0, 745, 746, 5, 483, 0, 0, 746, 748, 3, 548, 274, 0, 747, 745, 1, 0, 0, 0, 748, 751, 1, 0, 0, 0, 749, 747, 1, 0, 0, 0, 749, 750, 1, 0, 0, 0, 750, 752, 1, 0, 0, 0, 751, 749, 1, 0, 0, 0, 752, 753, 5, 71, 0, 0, 753, 758, 3, 546, 273, 0, 754, 755, 5, 280, 0, 0, 755, 757, 3, 546, 273, 0, 756, 754, 1, 0, 0, 0, 757, 760, 1, 0, 0, 0, 758, 756, 1, 0, 0, 0, 758, 759, 1, 0, 0, 0, 759, 766, 1, 0, 0, 0, 760, 758, 1, 0, 0, 0, 761, 764, 5, 284, 0, 0, 762, 765, 3, 684, 342, 0, 763, 765, 5, 503, 0, 0, 764, 762, 1, 0, 0, 0, 764, 763, 1, 0, 0, 0, 765, 767, 1, 0, 0, 0, 766, 761, 1, 0, 0, 0, 766, 767, 1, 0, 0, 0, 767, 770, 1, 0, 0, 0, 768, 769, 5, 421, 0, 0, 769, 771, 5, 422, 0, 0, 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 7, 1, 0, 0, 0, 772, 774, 3, 694, 347, 0, 773, 772, 1, 0, 0, 0, 773, 774, 1, 0, 0, 0, 774, 778, 1, 0, 0, 0, 775, 777, 3, 696, 348, 0, 776, 775, 1, 0, 0, 0, 777, 780, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 778, 779, 1, 0, 0, 0, 779, 781, 1, 0, 0, 0, 780, 778, 1, 0, 0, 0, 781, 784, 5, 17, 0, 0, 782, 783, 5, 281, 0, 0, 783, 785, 7, 0, 0, 0, 784, 782, 1, 0, 0, 0, 784, 785, 1, 0, 0, 0, 785, 806, 1, 0, 0, 0, 786, 807, 3, 84, 42, 0, 787, 807, 3, 116, 58, 0, 788, 807, 3, 132, 66, 0, 789, 807, 3, 160, 80, 0, 790, 807, 3, 162, 81, 0, 791, 807, 3, 310, 155, 0, 792, 807, 3, 312, 156, 0, 793, 807, 3, 138, 69, 0, 794, 807, 3, 150, 75, 0, 795, 807, 3, 416, 208, 0, 796, 807, 3, 424, 212, 0, 797, 807, 3, 432, 216, 0, 798, 807, 3, 438, 219, 0, 799, 807, 3, 458, 229, 0, 800, 807, 3, 460, 230, 0, 801, 807, 3, 462, 231, 0, 802, 807, 3, 482, 241, 0, 803, 807, 3, 484, 242, 0, 804, 807, 3, 490, 245, 0, 805, 807, 3, 496, 248, 0, 806, 786, 1, 0, 0, 0, 806, 787, 1, 0, 0, 0, 806, 788, 1, 0, 0, 0, 806, 789, 1, 0, 0, 0, 806, 790, 1, 0, 0, 0, 806, 791, 1, 0, 0, 0, 806, 792, 1, 0, 0, 0, 806, 793, 1, 0, 0, 0, 806, 794, 1, 0, 0, 0, 806, 795, 1, 0, 0, 0, 806, 796, 1, 0, 0, 0, 806, 797, 1, 0, 0, 0, 806, 798, 1, 0, 0, 0, 806, 799, 1, 0, 0, 0, 806, 800, 1, 0, 0, 0, 806, 801, 1, 0, 0, 0, 806, 802, 1, 0, 0, 0, 806, 803, 1, 0, 0, 0, 806, 804, 1, 0, 0, 0, 806, 805, 1, 0, 0, 0, 807, 9, 1, 0, 0, 0, 808, 809, 5, 18, 0, 0, 809, 810, 5, 23, 0, 0, 810, 812, 3, 684, 342, 0, 811, 813, 3, 124, 62, 0, 812, 811, 1, 0, 0, 0, 813, 814, 1, 0, 0, 0, 814, 812, 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 904, 1, 0, 0, 0, 816, 817, 5, 18, 0, 0, 817, 818, 5, 27, 0, 0, 818, 820, 3, 684, 342, 0, 819, 821, 3, 126, 63, 0, 820, 819, 1, 0, 0, 0, 821, 822, 1, 0, 0, 0, 822, 820, 1, 0, 0, 0, 822, 823, 1, 0, 0, 0, 823, 904, 1, 0, 0, 0, 824, 825, 5, 18, 0, 0, 825, 826, 5, 28, 0, 0, 826, 828, 3, 684, 342, 0, 827, 829, 3, 128, 64, 0, 828, 827, 1, 0, 0, 0, 829, 830, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 904, 1, 0, 0, 0, 832, 833, 5, 18, 0, 0, 833, 834, 5, 36, 0, 0, 834, 836, 3, 684, 342, 0, 835, 837, 3, 130, 65, 0, 836, 835, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 836, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, 839, 904, 1, 0, 0, 0, 840, 841, 5, 18, 0, 0, 841, 842, 5, 309, 0, 0, 842, 843, 5, 332, 0, 0, 843, 844, 3, 684, 342, 0, 844, 845, 5, 47, 0, 0, 845, 850, 3, 468, 234, 0, 846, 847, 5, 483, 0, 0, 847, 849, 3, 468, 234, 0, 848, 846, 1, 0, 0, 0, 849, 852, 1, 0, 0, 0, 850, 848, 1, 0, 0, 0, 850, 851, 1, 0, 0, 0, 851, 904, 1, 0, 0, 0, 852, 850, 1, 0, 0, 0, 853, 854, 5, 18, 0, 0, 854, 855, 5, 309, 0, 0, 855, 856, 5, 307, 0, 0, 856, 857, 3, 684, 342, 0, 857, 858, 5, 47, 0, 0, 858, 863, 3, 468, 234, 0, 859, 860, 5, 483, 0, 0, 860, 862, 3, 468, 234, 0, 861, 859, 1, 0, 0, 0, 862, 865, 1, 0, 0, 0, 863, 861, 1, 0, 0, 0, 863, 864, 1, 0, 0, 0, 864, 904, 1, 0, 0, 0, 865, 863, 1, 0, 0, 0, 866, 867, 5, 18, 0, 0, 867, 868, 5, 209, 0, 0, 868, 869, 5, 92, 0, 0, 869, 870, 7, 1, 0, 0, 870, 871, 3, 684, 342, 0, 871, 872, 5, 184, 0, 0, 872, 874, 5, 503, 0, 0, 873, 875, 3, 12, 6, 0, 874, 873, 1, 0, 0, 0, 875, 876, 1, 0, 0, 0, 876, 874, 1, 0, 0, 0, 876, 877, 1, 0, 0, 0, 877, 904, 1, 0, 0, 0, 878, 879, 5, 18, 0, 0, 879, 880, 5, 428, 0, 0, 880, 904, 3, 530, 265, 0, 881, 882, 5, 18, 0, 0, 882, 883, 5, 33, 0, 0, 883, 884, 3, 684, 342, 0, 884, 886, 5, 487, 0, 0, 885, 887, 3, 16, 8, 0, 886, 885, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 886, 1, 0, 0, 0, 888, 889, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 891, 5, 488, 0, 0, 891, 904, 1, 0, 0, 0, 892, 893, 5, 18, 0, 0, 893, 894, 5, 34, 0, 0, 894, 895, 3, 684, 342, 0, 895, 897, 5, 487, 0, 0, 896, 898, 3, 16, 8, 0, 897, 896, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 897, 1, 0, 0, 0, 899, 900, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, 902, 5, 488, 0, 0, 902, 904, 1, 0, 0, 0, 903, 808, 1, 0, 0, 0, 903, 816, 1, 0, 0, 0, 903, 824, 1, 0, 0, 0, 903, 832, 1, 0, 0, 0, 903, 840, 1, 0, 0, 0, 903, 853, 1, 0, 0, 0, 903, 866, 1, 0, 0, 0, 903, 878, 1, 0, 0, 0, 903, 881, 1, 0, 0, 0, 903, 892, 1, 0, 0, 0, 904, 11, 1, 0, 0, 0, 905, 906, 5, 47, 0, 0, 906, 911, 3, 14, 7, 0, 907, 908, 5, 483, 0, 0, 908, 910, 3, 14, 7, 0, 909, 907, 1, 0, 0, 0, 910, 913, 1, 0, 0, 0, 911, 909, 1, 0, 0, 0, 911, 912, 1, 0, 0, 0, 912, 918, 1, 0, 0, 0, 913, 911, 1, 0, 0, 0, 914, 915, 5, 210, 0, 0, 915, 916, 5, 206, 0, 0, 916, 918, 5, 207, 0, 0, 917, 905, 1, 0, 0, 0, 917, 914, 1, 0, 0, 0, 918, 13, 1, 0, 0, 0, 919, 920, 5, 203, 0, 0, 920, 921, 5, 472, 0, 0, 921, 935, 5, 499, 0, 0, 922, 923, 5, 204, 0, 0, 923, 924, 5, 472, 0, 0, 924, 935, 5, 499, 0, 0, 925, 926, 5, 499, 0, 0, 926, 927, 5, 472, 0, 0, 927, 935, 5, 499, 0, 0, 928, 929, 5, 499, 0, 0, 929, 930, 5, 472, 0, 0, 930, 935, 5, 92, 0, 0, 931, 932, 5, 499, 0, 0, 932, 933, 5, 472, 0, 0, 933, 935, 5, 467, 0, 0, 934, 919, 1, 0, 0, 0, 934, 922, 1, 0, 0, 0, 934, 925, 1, 0, 0, 0, 934, 928, 1, 0, 0, 0, 934, 931, 1, 0, 0, 0, 935, 15, 1, 0, 0, 0, 936, 938, 3, 18, 9, 0, 937, 939, 5, 482, 0, 0, 938, 937, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 939, 953, 1, 0, 0, 0, 940, 942, 3, 22, 11, 0, 941, 943, 5, 482, 0, 0, 942, 941, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 953, 1, 0, 0, 0, 944, 946, 3, 24, 12, 0, 945, 947, 5, 482, 0, 0, 946, 945, 1, 0, 0, 0, 946, 947, 1, 0, 0, 0, 947, 953, 1, 0, 0, 0, 948, 950, 3, 26, 13, 0, 949, 951, 5, 482, 0, 0, 950, 949, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 953, 1, 0, 0, 0, 952, 936, 1, 0, 0, 0, 952, 940, 1, 0, 0, 0, 952, 944, 1, 0, 0, 0, 952, 948, 1, 0, 0, 0, 953, 17, 1, 0, 0, 0, 954, 955, 5, 47, 0, 0, 955, 956, 3, 20, 10, 0, 956, 957, 5, 92, 0, 0, 957, 958, 3, 686, 343, 0, 958, 976, 1, 0, 0, 0, 959, 960, 5, 47, 0, 0, 960, 961, 5, 485, 0, 0, 961, 966, 3, 20, 10, 0, 962, 963, 5, 483, 0, 0, 963, 965, 3, 20, 10, 0, 964, 962, 1, 0, 0, 0, 965, 968, 1, 0, 0, 0, 966, 964, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 969, 1, 0, 0, 0, 968, 966, 1, 0, 0, 0, 969, 970, 5, 486, 0, 0, 970, 971, 5, 92, 0, 0, 971, 972, 3, 686, 343, 0, 972, 976, 1, 0, 0, 0, 973, 974, 5, 47, 0, 0, 974, 976, 3, 20, 10, 0, 975, 954, 1, 0, 0, 0, 975, 959, 1, 0, 0, 0, 975, 973, 1, 0, 0, 0, 976, 19, 1, 0, 0, 0, 977, 978, 3, 686, 343, 0, 978, 979, 5, 472, 0, 0, 979, 980, 3, 408, 204, 0, 980, 985, 1, 0, 0, 0, 981, 982, 5, 499, 0, 0, 982, 983, 5, 472, 0, 0, 983, 985, 3, 408, 204, 0, 984, 977, 1, 0, 0, 0, 984, 981, 1, 0, 0, 0, 985, 21, 1, 0, 0, 0, 986, 987, 5, 380, 0, 0, 987, 988, 5, 382, 0, 0, 988, 989, 3, 686, 343, 0, 989, 990, 5, 487, 0, 0, 990, 991, 3, 368, 184, 0, 991, 992, 5, 488, 0, 0, 992, 1001, 1, 0, 0, 0, 993, 994, 5, 380, 0, 0, 994, 995, 5, 381, 0, 0, 995, 996, 3, 686, 343, 0, 996, 997, 5, 487, 0, 0, 997, 998, 3, 368, 184, 0, 998, 999, 5, 488, 0, 0, 999, 1001, 1, 0, 0, 0, 1000, 986, 1, 0, 0, 0, 1000, 993, 1, 0, 0, 0, 1001, 23, 1, 0, 0, 0, 1002, 1003, 5, 19, 0, 0, 1003, 1004, 5, 184, 0, 0, 1004, 1009, 3, 686, 343, 0, 1005, 1006, 5, 483, 0, 0, 1006, 1008, 3, 686, 343, 0, 1007, 1005, 1, 0, 0, 0, 1008, 1011, 1, 0, 0, 0, 1009, 1007, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 25, 1, 0, 0, 0, 1011, 1009, 1, 0, 0, 0, 1012, 1013, 5, 415, 0, 0, 1013, 1014, 3, 686, 343, 0, 1014, 1015, 5, 137, 0, 0, 1015, 1016, 5, 487, 0, 0, 1016, 1017, 3, 368, 184, 0, 1017, 1018, 5, 488, 0, 0, 1018, 27, 1, 0, 0, 0, 1019, 1020, 5, 365, 0, 0, 1020, 1021, 7, 2, 0, 0, 1021, 1024, 3, 684, 342, 0, 1022, 1023, 5, 414, 0, 0, 1023, 1025, 3, 684, 342, 0, 1024, 1022, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1043, 1, 0, 0, 0, 1026, 1027, 5, 366, 0, 0, 1027, 1028, 5, 33, 0, 0, 1028, 1043, 3, 684, 342, 0, 1029, 1030, 5, 282, 0, 0, 1030, 1031, 5, 367, 0, 0, 1031, 1032, 5, 33, 0, 0, 1032, 1043, 3, 684, 342, 0, 1033, 1034, 5, 363, 0, 0, 1034, 1038, 5, 485, 0, 0, 1035, 1037, 3, 30, 15, 0, 1036, 1035, 1, 0, 0, 0, 1037, 1040, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1039, 1041, 1, 0, 0, 0, 1040, 1038, 1, 0, 0, 0, 1041, 1043, 5, 486, 0, 0, 1042, 1019, 1, 0, 0, 0, 1042, 1026, 1, 0, 0, 0, 1042, 1029, 1, 0, 0, 0, 1042, 1033, 1, 0, 0, 0, 1043, 29, 1, 0, 0, 0, 1044, 1045, 5, 363, 0, 0, 1045, 1046, 5, 154, 0, 0, 1046, 1051, 5, 499, 0, 0, 1047, 1048, 5, 33, 0, 0, 1048, 1052, 3, 684, 342, 0, 1049, 1050, 5, 30, 0, 0, 1050, 1052, 3, 684, 342, 0, 1051, 1047, 1, 0, 0, 0, 1051, 1049, 1, 0, 0, 0, 1051, 1052, 1, 0, 0, 0, 1052, 1054, 1, 0, 0, 0, 1053, 1055, 5, 482, 0, 0, 1054, 1053, 1, 0, 0, 0, 1054, 1055, 1, 0, 0, 0, 1055, 1070, 1, 0, 0, 0, 1056, 1057, 5, 363, 0, 0, 1057, 1058, 5, 499, 0, 0, 1058, 1062, 5, 485, 0, 0, 1059, 1061, 3, 30, 15, 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, 1067, 5, 486, 0, 0, 1066, 1068, 5, 482, 0, 0, 1067, 1066, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1044, 1, 0, 0, 0, 1069, 1056, 1, 0, 0, 0, 1070, 31, 1, 0, 0, 0, 1071, 1072, 5, 19, 0, 0, 1072, 1073, 5, 23, 0, 0, 1073, 1128, 3, 684, 342, 0, 1074, 1075, 5, 19, 0, 0, 1075, 1076, 5, 27, 0, 0, 1076, 1128, 3, 684, 342, 0, 1077, 1078, 5, 19, 0, 0, 1078, 1079, 5, 28, 0, 0, 1079, 1128, 3, 684, 342, 0, 1080, 1081, 5, 19, 0, 0, 1081, 1082, 5, 37, 0, 0, 1082, 1128, 3, 684, 342, 0, 1083, 1084, 5, 19, 0, 0, 1084, 1085, 5, 30, 0, 0, 1085, 1128, 3, 684, 342, 0, 1086, 1087, 5, 19, 0, 0, 1087, 1088, 5, 31, 0, 0, 1088, 1128, 3, 684, 342, 0, 1089, 1090, 5, 19, 0, 0, 1090, 1091, 5, 33, 0, 0, 1091, 1128, 3, 684, 342, 0, 1092, 1093, 5, 19, 0, 0, 1093, 1094, 5, 34, 0, 0, 1094, 1128, 3, 684, 342, 0, 1095, 1096, 5, 19, 0, 0, 1096, 1097, 5, 29, 0, 0, 1097, 1128, 3, 684, 342, 0, 1098, 1099, 5, 19, 0, 0, 1099, 1100, 5, 36, 0, 0, 1100, 1128, 3, 684, 342, 0, 1101, 1102, 5, 19, 0, 0, 1102, 1103, 5, 113, 0, 0, 1103, 1104, 5, 114, 0, 0, 1104, 1128, 3, 684, 342, 0, 1105, 1106, 5, 19, 0, 0, 1106, 1107, 5, 41, 0, 0, 1107, 1108, 3, 684, 342, 0, 1108, 1109, 5, 92, 0, 0, 1109, 1110, 3, 684, 342, 0, 1110, 1128, 1, 0, 0, 0, 1111, 1112, 5, 19, 0, 0, 1112, 1113, 5, 309, 0, 0, 1113, 1114, 5, 332, 0, 0, 1114, 1128, 3, 684, 342, 0, 1115, 1116, 5, 19, 0, 0, 1116, 1117, 5, 309, 0, 0, 1117, 1118, 5, 307, 0, 0, 1118, 1128, 3, 684, 342, 0, 1119, 1120, 5, 19, 0, 0, 1120, 1121, 5, 425, 0, 0, 1121, 1122, 5, 426, 0, 0, 1122, 1123, 5, 307, 0, 0, 1123, 1128, 3, 684, 342, 0, 1124, 1125, 5, 19, 0, 0, 1125, 1126, 5, 32, 0, 0, 1126, 1128, 3, 684, 342, 0, 1127, 1071, 1, 0, 0, 0, 1127, 1074, 1, 0, 0, 0, 1127, 1077, 1, 0, 0, 0, 1127, 1080, 1, 0, 0, 0, 1127, 1083, 1, 0, 0, 0, 1127, 1086, 1, 0, 0, 0, 1127, 1089, 1, 0, 0, 0, 1127, 1092, 1, 0, 0, 0, 1127, 1095, 1, 0, 0, 0, 1127, 1098, 1, 0, 0, 0, 1127, 1101, 1, 0, 0, 0, 1127, 1105, 1, 0, 0, 0, 1127, 1111, 1, 0, 0, 0, 1127, 1115, 1, 0, 0, 0, 1127, 1119, 1, 0, 0, 0, 1127, 1124, 1, 0, 0, 0, 1128, 33, 1, 0, 0, 0, 1129, 1130, 5, 20, 0, 0, 1130, 1131, 5, 23, 0, 0, 1131, 1132, 3, 684, 342, 0, 1132, 1133, 5, 411, 0, 0, 1133, 1134, 5, 503, 0, 0, 1134, 1141, 1, 0, 0, 0, 1135, 1136, 5, 20, 0, 0, 1136, 1137, 5, 29, 0, 0, 1137, 1138, 5, 503, 0, 0, 1138, 1139, 5, 411, 0, 0, 1139, 1141, 5, 503, 0, 0, 1140, 1129, 1, 0, 0, 0, 1140, 1135, 1, 0, 0, 0, 1141, 35, 1, 0, 0, 0, 1142, 1151, 5, 21, 0, 0, 1143, 1152, 5, 33, 0, 0, 1144, 1152, 5, 30, 0, 0, 1145, 1152, 5, 34, 0, 0, 1146, 1152, 5, 31, 0, 0, 1147, 1152, 5, 28, 0, 0, 1148, 1152, 5, 37, 0, 0, 1149, 1150, 5, 344, 0, 0, 1150, 1152, 5, 343, 0, 0, 1151, 1143, 1, 0, 0, 0, 1151, 1144, 1, 0, 0, 0, 1151, 1145, 1, 0, 0, 0, 1151, 1146, 1, 0, 0, 0, 1151, 1147, 1, 0, 0, 0, 1151, 1148, 1, 0, 0, 0, 1151, 1149, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1154, 3, 684, 342, 0, 1154, 1155, 5, 411, 0, 0, 1155, 1156, 5, 215, 0, 0, 1156, 1162, 5, 499, 0, 0, 1157, 1160, 5, 284, 0, 0, 1158, 1161, 3, 684, 342, 0, 1159, 1161, 5, 503, 0, 0, 1160, 1158, 1, 0, 0, 0, 1160, 1159, 1, 0, 0, 0, 1161, 1163, 1, 0, 0, 0, 1162, 1157, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1190, 1, 0, 0, 0, 1164, 1173, 5, 21, 0, 0, 1165, 1174, 5, 33, 0, 0, 1166, 1174, 5, 30, 0, 0, 1167, 1174, 5, 34, 0, 0, 1168, 1174, 5, 31, 0, 0, 1169, 1174, 5, 28, 0, 0, 1170, 1174, 5, 37, 0, 0, 1171, 1172, 5, 344, 0, 0, 1172, 1174, 5, 343, 0, 0, 1173, 1165, 1, 0, 0, 0, 1173, 1166, 1, 0, 0, 0, 1173, 1167, 1, 0, 0, 0, 1173, 1168, 1, 0, 0, 0, 1173, 1169, 1, 0, 0, 0, 1173, 1170, 1, 0, 0, 0, 1173, 1171, 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1175, 1176, 3, 684, 342, 0, 1176, 1179, 5, 411, 0, 0, 1177, 1180, 3, 684, 342, 0, 1178, 1180, 5, 503, 0, 0, 1179, 1177, 1, 0, 0, 0, 1179, 1178, 1, 0, 0, 0, 1180, 1190, 1, 0, 0, 0, 1181, 1182, 5, 21, 0, 0, 1182, 1183, 5, 23, 0, 0, 1183, 1184, 3, 684, 342, 0, 1184, 1187, 5, 411, 0, 0, 1185, 1188, 3, 684, 342, 0, 1186, 1188, 5, 503, 0, 0, 1187, 1185, 1, 0, 0, 0, 1187, 1186, 1, 0, 0, 0, 1188, 1190, 1, 0, 0, 0, 1189, 1142, 1, 0, 0, 0, 1189, 1164, 1, 0, 0, 0, 1189, 1181, 1, 0, 0, 0, 1190, 37, 1, 0, 0, 0, 1191, 1211, 3, 40, 20, 0, 1192, 1211, 3, 42, 21, 0, 1193, 1211, 3, 44, 22, 0, 1194, 1211, 3, 46, 23, 0, 1195, 1211, 3, 48, 24, 0, 1196, 1211, 3, 50, 25, 0, 1197, 1211, 3, 52, 26, 0, 1198, 1211, 3, 54, 27, 0, 1199, 1211, 3, 56, 28, 0, 1200, 1211, 3, 58, 29, 0, 1201, 1211, 3, 60, 30, 0, 1202, 1211, 3, 62, 31, 0, 1203, 1211, 3, 64, 32, 0, 1204, 1211, 3, 66, 33, 0, 1205, 1211, 3, 68, 34, 0, 1206, 1211, 3, 70, 35, 0, 1207, 1211, 3, 72, 36, 0, 1208, 1211, 3, 74, 37, 0, 1209, 1211, 3, 76, 38, 0, 1210, 1191, 1, 0, 0, 0, 1210, 1192, 1, 0, 0, 0, 1210, 1193, 1, 0, 0, 0, 1210, 1194, 1, 0, 0, 0, 1210, 1195, 1, 0, 0, 0, 1210, 1196, 1, 0, 0, 0, 1210, 1197, 1, 0, 0, 0, 1210, 1198, 1, 0, 0, 0, 1210, 1199, 1, 0, 0, 0, 1210, 1200, 1, 0, 0, 0, 1210, 1201, 1, 0, 0, 0, 1210, 1202, 1, 0, 0, 0, 1210, 1203, 1, 0, 0, 0, 1210, 1204, 1, 0, 0, 0, 1210, 1205, 1, 0, 0, 0, 1210, 1206, 1, 0, 0, 0, 1210, 1207, 1, 0, 0, 0, 1210, 1208, 1, 0, 0, 0, 1210, 1209, 1, 0, 0, 0, 1211, 39, 1, 0, 0, 0, 1212, 1213, 5, 17, 0, 0, 1213, 1214, 5, 29, 0, 0, 1214, 1215, 5, 431, 0, 0, 1215, 1218, 3, 684, 342, 0, 1216, 1217, 5, 465, 0, 0, 1217, 1219, 5, 499, 0, 0, 1218, 1216, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 41, 1, 0, 0, 0, 1220, 1221, 5, 19, 0, 0, 1221, 1222, 5, 29, 0, 0, 1222, 1223, 5, 431, 0, 0, 1223, 1224, 3, 684, 342, 0, 1224, 43, 1, 0, 0, 0, 1225, 1226, 5, 17, 0, 0, 1226, 1227, 5, 443, 0, 0, 1227, 1228, 5, 431, 0, 0, 1228, 1229, 3, 686, 343, 0, 1229, 1230, 5, 485, 0, 0, 1230, 1231, 3, 78, 39, 0, 1231, 1235, 5, 486, 0, 0, 1232, 1233, 5, 437, 0, 0, 1233, 1234, 5, 84, 0, 0, 1234, 1236, 5, 432, 0, 0, 1235, 1232, 1, 0, 0, 0, 1235, 1236, 1, 0, 0, 0, 1236, 45, 1, 0, 0, 0, 1237, 1238, 5, 18, 0, 0, 1238, 1239, 5, 443, 0, 0, 1239, 1240, 5, 431, 0, 0, 1240, 1241, 3, 686, 343, 0, 1241, 1242, 5, 46, 0, 0, 1242, 1243, 5, 29, 0, 0, 1243, 1244, 5, 432, 0, 0, 1244, 1245, 5, 485, 0, 0, 1245, 1246, 3, 78, 39, 0, 1246, 1247, 5, 486, 0, 0, 1247, 1260, 1, 0, 0, 0, 1248, 1249, 5, 18, 0, 0, 1249, 1250, 5, 443, 0, 0, 1250, 1251, 5, 431, 0, 0, 1251, 1252, 3, 686, 343, 0, 1252, 1253, 5, 131, 0, 0, 1253, 1254, 5, 29, 0, 0, 1254, 1255, 5, 432, 0, 0, 1255, 1256, 5, 485, 0, 0, 1256, 1257, 3, 78, 39, 0, 1257, 1258, 5, 486, 0, 0, 1258, 1260, 1, 0, 0, 0, 1259, 1237, 1, 0, 0, 0, 1259, 1248, 1, 0, 0, 0, 1260, 47, 1, 0, 0, 0, 1261, 1262, 5, 19, 0, 0, 1262, 1263, 5, 443, 0, 0, 1263, 1264, 5, 431, 0, 0, 1264, 1265, 3, 686, 343, 0, 1265, 49, 1, 0, 0, 0, 1266, 1267, 5, 433, 0, 0, 1267, 1268, 3, 78, 39, 0, 1268, 1269, 5, 92, 0, 0, 1269, 1270, 3, 684, 342, 0, 1270, 1271, 5, 485, 0, 0, 1271, 1272, 3, 80, 40, 0, 1272, 1275, 5, 486, 0, 0, 1273, 1274, 5, 71, 0, 0, 1274, 1276, 5, 499, 0, 0, 1275, 1273, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 51, 1, 0, 0, 0, 1277, 1278, 5, 434, 0, 0, 1278, 1279, 3, 78, 39, 0, 1279, 1280, 5, 92, 0, 0, 1280, 1281, 3, 684, 342, 0, 1281, 53, 1, 0, 0, 0, 1282, 1283, 5, 433, 0, 0, 1283, 1284, 5, 387, 0, 0, 1284, 1285, 5, 92, 0, 0, 1285, 1286, 5, 30, 0, 0, 1286, 1287, 3, 684, 342, 0, 1287, 1288, 5, 411, 0, 0, 1288, 1289, 3, 78, 39, 0, 1289, 55, 1, 0, 0, 0, 1290, 1291, 5, 434, 0, 0, 1291, 1292, 5, 387, 0, 0, 1292, 1293, 5, 92, 0, 0, 1293, 1294, 5, 30, 0, 0, 1294, 1295, 3, 684, 342, 0, 1295, 1296, 5, 70, 0, 0, 1296, 1297, 3, 78, 39, 0, 1297, 57, 1, 0, 0, 0, 1298, 1299, 5, 433, 0, 0, 1299, 1300, 5, 25, 0, 0, 1300, 1301, 5, 92, 0, 0, 1301, 1302, 5, 33, 0, 0, 1302, 1303, 3, 684, 342, 0, 1303, 1304, 5, 411, 0, 0, 1304, 1305, 3, 78, 39, 0, 1305, 59, 1, 0, 0, 0, 1306, 1307, 5, 434, 0, 0, 1307, 1308, 5, 25, 0, 0, 1308, 1309, 5, 92, 0, 0, 1309, 1310, 5, 33, 0, 0, 1310, 1311, 3, 684, 342, 0, 1311, 1312, 5, 70, 0, 0, 1312, 1313, 3, 78, 39, 0, 1313, 61, 1, 0, 0, 0, 1314, 1315, 5, 433, 0, 0, 1315, 1316, 5, 387, 0, 0, 1316, 1317, 5, 92, 0, 0, 1317, 1318, 5, 32, 0, 0, 1318, 1319, 3, 684, 342, 0, 1319, 1320, 5, 411, 0, 0, 1320, 1321, 3, 78, 39, 0, 1321, 63, 1, 0, 0, 0, 1322, 1323, 5, 434, 0, 0, 1323, 1324, 5, 387, 0, 0, 1324, 1325, 5, 92, 0, 0, 1325, 1326, 5, 32, 0, 0, 1326, 1327, 3, 684, 342, 0, 1327, 1328, 5, 70, 0, 0, 1328, 1329, 3, 78, 39, 0, 1329, 65, 1, 0, 0, 0, 1330, 1331, 5, 433, 0, 0, 1331, 1332, 5, 441, 0, 0, 1332, 1333, 5, 92, 0, 0, 1333, 1334, 5, 309, 0, 0, 1334, 1335, 5, 307, 0, 0, 1335, 1336, 3, 684, 342, 0, 1336, 1337, 5, 411, 0, 0, 1337, 1338, 3, 78, 39, 0, 1338, 67, 1, 0, 0, 0, 1339, 1340, 5, 434, 0, 0, 1340, 1341, 5, 441, 0, 0, 1341, 1342, 5, 92, 0, 0, 1342, 1343, 5, 309, 0, 0, 1343, 1344, 5, 307, 0, 0, 1344, 1345, 3, 684, 342, 0, 1345, 1346, 5, 70, 0, 0, 1346, 1347, 3, 78, 39, 0, 1347, 69, 1, 0, 0, 0, 1348, 1349, 5, 18, 0, 0, 1349, 1350, 5, 58, 0, 0, 1350, 1351, 5, 430, 0, 0, 1351, 1352, 5, 442, 0, 0, 1352, 1360, 7, 3, 0, 0, 1353, 1354, 5, 18, 0, 0, 1354, 1355, 5, 58, 0, 0, 1355, 1356, 5, 430, 0, 0, 1356, 1357, 5, 438, 0, 0, 1357, 1358, 5, 468, 0, 0, 1358, 1360, 7, 4, 0, 0, 1359, 1348, 1, 0, 0, 0, 1359, 1353, 1, 0, 0, 0, 1360, 71, 1, 0, 0, 0, 1361, 1362, 5, 17, 0, 0, 1362, 1363, 5, 438, 0, 0, 1363, 1364, 5, 443, 0, 0, 1364, 1365, 5, 499, 0, 0, 1365, 1366, 5, 342, 0, 0, 1366, 1369, 5, 499, 0, 0, 1367, 1368, 5, 23, 0, 0, 1368, 1370, 3, 684, 342, 0, 1369, 1367, 1, 0, 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 1372, 5, 485, 0, 0, 1372, 1377, 3, 686, 343, 0, 1373, 1374, 5, 483, 0, 0, 1374, 1376, 3, 686, 343, 0, 1375, 1373, 1, 0, 0, 0, 1376, 1379, 1, 0, 0, 0, 1377, 1375, 1, 0, 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 1380, 1, 0, 0, 0, 1379, 1377, 1, 0, 0, 0, 1380, 1381, 5, 486, 0, 0, 1381, 73, 1, 0, 0, 0, 1382, 1383, 5, 19, 0, 0, 1383, 1384, 5, 438, 0, 0, 1384, 1385, 5, 443, 0, 0, 1385, 1386, 5, 499, 0, 0, 1386, 75, 1, 0, 0, 0, 1387, 1388, 5, 383, 0, 0, 1388, 1391, 5, 430, 0, 0, 1389, 1390, 5, 284, 0, 0, 1390, 1392, 3, 684, 342, 0, 1391, 1389, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 77, 1, 0, 0, 0, 1393, 1398, 3, 684, 342, 0, 1394, 1395, 5, 483, 0, 0, 1395, 1397, 3, 684, 342, 0, 1396, 1394, 1, 0, 0, 0, 1397, 1400, 1, 0, 0, 0, 1398, 1396, 1, 0, 0, 0, 1398, 1399, 1, 0, 0, 0, 1399, 79, 1, 0, 0, 0, 1400, 1398, 1, 0, 0, 0, 1401, 1406, 3, 82, 41, 0, 1402, 1403, 5, 483, 0, 0, 1403, 1405, 3, 82, 41, 0, 1404, 1402, 1, 0, 0, 0, 1405, 1408, 1, 0, 0, 0, 1406, 1404, 1, 0, 0, 0, 1406, 1407, 1, 0, 0, 0, 1407, 81, 1, 0, 0, 0, 1408, 1406, 1, 0, 0, 0, 1409, 1438, 5, 17, 0, 0, 1410, 1438, 5, 99, 0, 0, 1411, 1412, 5, 463, 0, 0, 1412, 1438, 5, 477, 0, 0, 1413, 1414, 5, 463, 0, 0, 1414, 1415, 5, 485, 0, 0, 1415, 1420, 5, 503, 0, 0, 1416, 1417, 5, 483, 0, 0, 1417, 1419, 5, 503, 0, 0, 1418, 1416, 1, 0, 0, 0, 1419, 1422, 1, 0, 0, 0, 1420, 1418, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1423, 1, 0, 0, 0, 1422, 1420, 1, 0, 0, 0, 1423, 1438, 5, 486, 0, 0, 1424, 1425, 5, 464, 0, 0, 1425, 1438, 5, 477, 0, 0, 1426, 1427, 5, 464, 0, 0, 1427, 1428, 5, 485, 0, 0, 1428, 1433, 5, 503, 0, 0, 1429, 1430, 5, 483, 0, 0, 1430, 1432, 5, 503, 0, 0, 1431, 1429, 1, 0, 0, 0, 1432, 1435, 1, 0, 0, 0, 1433, 1431, 1, 0, 0, 0, 1433, 1434, 1, 0, 0, 0, 1434, 1436, 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1436, 1438, 5, 486, 0, 0, 1437, 1409, 1, 0, 0, 0, 1437, 1410, 1, 0, 0, 0, 1437, 1411, 1, 0, 0, 0, 1437, 1413, 1, 0, 0, 0, 1437, 1424, 1, 0, 0, 0, 1437, 1426, 1, 0, 0, 0, 1438, 83, 1, 0, 0, 0, 1439, 1440, 5, 24, 0, 0, 1440, 1441, 5, 23, 0, 0, 1441, 1443, 3, 684, 342, 0, 1442, 1444, 3, 86, 43, 0, 1443, 1442, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 1446, 1, 0, 0, 0, 1445, 1447, 3, 88, 44, 0, 1446, 1445, 1, 0, 0, 0, 1446, 1447, 1, 0, 0, 0, 1447, 1486, 1, 0, 0, 0, 1448, 1449, 5, 11, 0, 0, 1449, 1450, 5, 23, 0, 0, 1450, 1452, 3, 684, 342, 0, 1451, 1453, 3, 86, 43, 0, 1452, 1451, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 1455, 1, 0, 0, 0, 1454, 1456, 3, 88, 44, 0, 1455, 1454, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, 1486, 1, 0, 0, 0, 1457, 1458, 5, 25, 0, 0, 1458, 1459, 5, 23, 0, 0, 1459, 1461, 3, 684, 342, 0, 1460, 1462, 3, 88, 44, 0, 1461, 1460, 1, 0, 0, 0, 1461, 1462, 1, 0, 0, 0, 1462, 1463, 1, 0, 0, 0, 1463, 1465, 5, 75, 0, 0, 1464, 1466, 5, 485, 0, 0, 1465, 1464, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1467, 1, 0, 0, 0, 1467, 1469, 3, 560, 280, 0, 1468, 1470, 5, 486, 0, 0, 1469, 1468, 1, 0, 0, 0, 1469, 1470, 1, 0, 0, 0, 1470, 1486, 1, 0, 0, 0, 1471, 1472, 5, 26, 0, 0, 1472, 1473, 5, 23, 0, 0, 1473, 1475, 3, 684, 342, 0, 1474, 1476, 3, 88, 44, 0, 1475, 1474, 1, 0, 0, 0, 1475, 1476, 1, 0, 0, 0, 1476, 1486, 1, 0, 0, 0, 1477, 1478, 5, 23, 0, 0, 1478, 1480, 3, 684, 342, 0, 1479, 1481, 3, 86, 43, 0, 1480, 1479, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, 1483, 1, 0, 0, 0, 1482, 1484, 3, 88, 44, 0, 1483, 1482, 1, 0, 0, 0, 1483, 1484, 1, 0, 0, 0, 1484, 1486, 1, 0, 0, 0, 1485, 1439, 1, 0, 0, 0, 1485, 1448, 1, 0, 0, 0, 1485, 1457, 1, 0, 0, 0, 1485, 1471, 1, 0, 0, 0, 1485, 1477, 1, 0, 0, 0, 1486, 85, 1, 0, 0, 0, 1487, 1488, 5, 45, 0, 0, 1488, 1492, 3, 684, 342, 0, 1489, 1490, 5, 44, 0, 0, 1490, 1492, 3, 684, 342, 0, 1491, 1487, 1, 0, 0, 0, 1491, 1489, 1, 0, 0, 0, 1492, 87, 1, 0, 0, 0, 1493, 1495, 5, 485, 0, 0, 1494, 1496, 3, 94, 47, 0, 1495, 1494, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, 1499, 5, 486, 0, 0, 1498, 1500, 3, 90, 45, 0, 1499, 1498, 1, 0, 0, 0, 1499, 1500, 1, 0, 0, 0, 1500, 1503, 1, 0, 0, 0, 1501, 1503, 3, 90, 45, 0, 1502, 1493, 1, 0, 0, 0, 1502, 1501, 1, 0, 0, 0, 1503, 89, 1, 0, 0, 0, 1504, 1511, 3, 92, 46, 0, 1505, 1507, 5, 483, 0, 0, 1506, 1505, 1, 0, 0, 0, 1506, 1507, 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 1510, 3, 92, 46, 0, 1509, 1506, 1, 0, 0, 0, 1510, 1513, 1, 0, 0, 0, 1511, 1509, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 91, 1, 0, 0, 0, 1513, 1511, 1, 0, 0, 0, 1514, 1515, 5, 394, 0, 0, 1515, 1519, 5, 499, 0, 0, 1516, 1517, 5, 41, 0, 0, 1517, 1519, 3, 108, 54, 0, 1518, 1514, 1, 0, 0, 0, 1518, 1516, 1, 0, 0, 0, 1519, 93, 1, 0, 0, 0, 1520, 1525, 3, 96, 48, 0, 1521, 1522, 5, 483, 0, 0, 1522, 1524, 3, 96, 48, 0, 1523, 1521, 1, 0, 0, 0, 1524, 1527, 1, 0, 0, 0, 1525, 1523, 1, 0, 0, 0, 1525, 1526, 1, 0, 0, 0, 1526, 95, 1, 0, 0, 0, 1527, 1525, 1, 0, 0, 0, 1528, 1530, 3, 694, 347, 0, 1529, 1528, 1, 0, 0, 0, 1529, 1530, 1, 0, 0, 0, 1530, 1534, 1, 0, 0, 0, 1531, 1533, 3, 696, 348, 0, 1532, 1531, 1, 0, 0, 0, 1533, 1536, 1, 0, 0, 0, 1534, 1532, 1, 0, 0, 0, 1534, 1535, 1, 0, 0, 0, 1535, 1537, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1537, 1538, 3, 98, 49, 0, 1538, 1539, 5, 491, 0, 0, 1539, 1543, 3, 102, 51, 0, 1540, 1542, 3, 100, 50, 0, 1541, 1540, 1, 0, 0, 0, 1542, 1545, 1, 0, 0, 0, 1543, 1541, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 97, 1, 0, 0, 0, 1545, 1543, 1, 0, 0, 0, 1546, 1550, 5, 503, 0, 0, 1547, 1550, 5, 505, 0, 0, 1548, 1550, 3, 706, 353, 0, 1549, 1546, 1, 0, 0, 0, 1549, 1547, 1, 0, 0, 0, 1549, 1548, 1, 0, 0, 0, 1550, 99, 1, 0, 0, 0, 1551, 1554, 5, 7, 0, 0, 1552, 1553, 5, 297, 0, 0, 1553, 1555, 5, 499, 0, 0, 1554, 1552, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1585, 1, 0, 0, 0, 1556, 1557, 5, 282, 0, 0, 1557, 1560, 5, 283, 0, 0, 1558, 1559, 5, 297, 0, 0, 1559, 1561, 5, 499, 0, 0, 1560, 1558, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1585, 1, 0, 0, 0, 1562, 1565, 5, 289, 0, 0, 1563, 1564, 5, 297, 0, 0, 1564, 1566, 5, 499, 0, 0, 1565, 1563, 1, 0, 0, 0, 1565, 1566, 1, 0, 0, 0, 1566, 1585, 1, 0, 0, 0, 1567, 1570, 5, 290, 0, 0, 1568, 1571, 3, 688, 344, 0, 1569, 1571, 3, 646, 323, 0, 1570, 1568, 1, 0, 0, 0, 1570, 1569, 1, 0, 0, 0, 1571, 1585, 1, 0, 0, 0, 1572, 1575, 5, 296, 0, 0, 1573, 1574, 5, 297, 0, 0, 1574, 1576, 5, 499, 0, 0, 1575, 1573, 1, 0, 0, 0, 1575, 1576, 1, 0, 0, 0, 1576, 1585, 1, 0, 0, 0, 1577, 1582, 5, 305, 0, 0, 1578, 1580, 5, 462, 0, 0, 1579, 1578, 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 1583, 3, 684, 342, 0, 1582, 1579, 1, 0, 0, 0, 1582, 1583, 1, 0, 0, 0, 1583, 1585, 1, 0, 0, 0, 1584, 1551, 1, 0, 0, 0, 1584, 1556, 1, 0, 0, 0, 1584, 1562, 1, 0, 0, 0, 1584, 1567, 1, 0, 0, 0, 1584, 1572, 1, 0, 0, 0, 1584, 1577, 1, 0, 0, 0, 1585, 101, 1, 0, 0, 0, 1586, 1590, 5, 257, 0, 0, 1587, 1588, 5, 485, 0, 0, 1588, 1589, 5, 501, 0, 0, 1589, 1591, 5, 486, 0, 0, 1590, 1587, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, 0, 1591, 1623, 1, 0, 0, 0, 1592, 1623, 5, 258, 0, 0, 1593, 1623, 5, 259, 0, 0, 1594, 1623, 5, 260, 0, 0, 1595, 1623, 5, 261, 0, 0, 1596, 1623, 5, 262, 0, 0, 1597, 1623, 5, 263, 0, 0, 1598, 1623, 5, 264, 0, 0, 1599, 1623, 5, 265, 0, 0, 1600, 1623, 5, 266, 0, 0, 1601, 1623, 5, 267, 0, 0, 1602, 1623, 5, 268, 0, 0, 1603, 1604, 5, 269, 0, 0, 1604, 1605, 5, 485, 0, 0, 1605, 1606, 3, 104, 52, 0, 1606, 1607, 5, 486, 0, 0, 1607, 1623, 1, 0, 0, 0, 1608, 1609, 5, 23, 0, 0, 1609, 1610, 5, 473, 0, 0, 1610, 1611, 5, 503, 0, 0, 1611, 1623, 5, 474, 0, 0, 1612, 1613, 5, 270, 0, 0, 1613, 1623, 3, 684, 342, 0, 1614, 1615, 5, 28, 0, 0, 1615, 1616, 5, 485, 0, 0, 1616, 1617, 3, 684, 342, 0, 1617, 1618, 5, 486, 0, 0, 1618, 1623, 1, 0, 0, 0, 1619, 1620, 5, 13, 0, 0, 1620, 1623, 3, 684, 342, 0, 1621, 1623, 3, 684, 342, 0, 1622, 1586, 1, 0, 0, 0, 1622, 1592, 1, 0, 0, 0, 1622, 1593, 1, 0, 0, 0, 1622, 1594, 1, 0, 0, 0, 1622, 1595, 1, 0, 0, 0, 1622, 1596, 1, 0, 0, 0, 1622, 1597, 1, 0, 0, 0, 1622, 1598, 1, 0, 0, 0, 1622, 1599, 1, 0, 0, 0, 1622, 1600, 1, 0, 0, 0, 1622, 1601, 1, 0, 0, 0, 1622, 1602, 1, 0, 0, 0, 1622, 1603, 1, 0, 0, 0, 1622, 1608, 1, 0, 0, 0, 1622, 1612, 1, 0, 0, 0, 1622, 1614, 1, 0, 0, 0, 1622, 1619, 1, 0, 0, 0, 1622, 1621, 1, 0, 0, 0, 1623, 103, 1, 0, 0, 0, 1624, 1625, 7, 5, 0, 0, 1625, 105, 1, 0, 0, 0, 1626, 1630, 5, 257, 0, 0, 1627, 1628, 5, 485, 0, 0, 1628, 1629, 5, 501, 0, 0, 1629, 1631, 5, 486, 0, 0, 1630, 1627, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1652, 1, 0, 0, 0, 1632, 1652, 5, 258, 0, 0, 1633, 1652, 5, 259, 0, 0, 1634, 1652, 5, 260, 0, 0, 1635, 1652, 5, 261, 0, 0, 1636, 1652, 5, 262, 0, 0, 1637, 1652, 5, 263, 0, 0, 1638, 1652, 5, 264, 0, 0, 1639, 1652, 5, 265, 0, 0, 1640, 1652, 5, 266, 0, 0, 1641, 1652, 5, 267, 0, 0, 1642, 1652, 5, 268, 0, 0, 1643, 1644, 5, 270, 0, 0, 1644, 1652, 3, 684, 342, 0, 1645, 1646, 5, 28, 0, 0, 1646, 1647, 5, 485, 0, 0, 1647, 1648, 3, 684, 342, 0, 1648, 1649, 5, 486, 0, 0, 1649, 1652, 1, 0, 0, 0, 1650, 1652, 3, 684, 342, 0, 1651, 1626, 1, 0, 0, 0, 1651, 1632, 1, 0, 0, 0, 1651, 1633, 1, 0, 0, 0, 1651, 1634, 1, 0, 0, 0, 1651, 1635, 1, 0, 0, 0, 1651, 1636, 1, 0, 0, 0, 1651, 1637, 1, 0, 0, 0, 1651, 1638, 1, 0, 0, 0, 1651, 1639, 1, 0, 0, 0, 1651, 1640, 1, 0, 0, 0, 1651, 1641, 1, 0, 0, 0, 1651, 1642, 1, 0, 0, 0, 1651, 1643, 1, 0, 0, 0, 1651, 1645, 1, 0, 0, 0, 1651, 1650, 1, 0, 0, 0, 1652, 107, 1, 0, 0, 0, 1653, 1655, 5, 503, 0, 0, 1654, 1653, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1656, 1, 0, 0, 0, 1656, 1657, 5, 485, 0, 0, 1657, 1658, 3, 110, 55, 0, 1658, 1659, 5, 486, 0, 0, 1659, 109, 1, 0, 0, 0, 1660, 1665, 3, 112, 56, 0, 1661, 1662, 5, 483, 0, 0, 1662, 1664, 3, 112, 56, 0, 1663, 1661, 1, 0, 0, 0, 1664, 1667, 1, 0, 0, 0, 1665, 1663, 1, 0, 0, 0, 1665, 1666, 1, 0, 0, 0, 1666, 111, 1, 0, 0, 0, 1667, 1665, 1, 0, 0, 0, 1668, 1670, 3, 114, 57, 0, 1669, 1671, 7, 6, 0, 0, 1670, 1669, 1, 0, 0, 0, 1670, 1671, 1, 0, 0, 0, 1671, 113, 1, 0, 0, 0, 1672, 1676, 5, 503, 0, 0, 1673, 1676, 5, 505, 0, 0, 1674, 1676, 3, 706, 353, 0, 1675, 1672, 1, 0, 0, 0, 1675, 1673, 1, 0, 0, 0, 1675, 1674, 1, 0, 0, 0, 1676, 115, 1, 0, 0, 0, 1677, 1678, 5, 27, 0, 0, 1678, 1679, 3, 684, 342, 0, 1679, 1680, 5, 70, 0, 0, 1680, 1681, 3, 684, 342, 0, 1681, 1682, 5, 411, 0, 0, 1682, 1684, 3, 684, 342, 0, 1683, 1685, 3, 118, 59, 0, 1684, 1683, 1, 0, 0, 0, 1684, 1685, 1, 0, 0, 0, 1685, 117, 1, 0, 0, 0, 1686, 1688, 3, 120, 60, 0, 1687, 1686, 1, 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1687, 1, 0, 0, 0, 1689, 1690, 1, 0, 0, 0, 1690, 119, 1, 0, 0, 0, 1691, 1692, 5, 405, 0, 0, 1692, 1702, 7, 7, 0, 0, 1693, 1694, 5, 42, 0, 0, 1694, 1702, 7, 8, 0, 0, 1695, 1696, 5, 50, 0, 0, 1696, 1702, 7, 9, 0, 0, 1697, 1698, 5, 52, 0, 0, 1698, 1702, 3, 122, 61, 0, 1699, 1700, 5, 394, 0, 0, 1700, 1702, 5, 499, 0, 0, 1701, 1691, 1, 0, 0, 0, 1701, 1693, 1, 0, 0, 0, 1701, 1695, 1, 0, 0, 0, 1701, 1697, 1, 0, 0, 0, 1701, 1699, 1, 0, 0, 0, 1702, 121, 1, 0, 0, 0, 1703, 1704, 7, 10, 0, 0, 1704, 123, 1, 0, 0, 0, 1705, 1706, 5, 46, 0, 0, 1706, 1707, 5, 38, 0, 0, 1707, 1762, 3, 96, 48, 0, 1708, 1709, 5, 46, 0, 0, 1709, 1710, 5, 39, 0, 0, 1710, 1762, 3, 96, 48, 0, 1711, 1712, 5, 20, 0, 0, 1712, 1713, 5, 38, 0, 0, 1713, 1714, 3, 98, 49, 0, 1714, 1715, 5, 411, 0, 0, 1715, 1716, 3, 98, 49, 0, 1716, 1762, 1, 0, 0, 0, 1717, 1718, 5, 20, 0, 0, 1718, 1719, 5, 39, 0, 0, 1719, 1720, 3, 98, 49, 0, 1720, 1721, 5, 411, 0, 0, 1721, 1722, 3, 98, 49, 0, 1722, 1762, 1, 0, 0, 0, 1723, 1724, 5, 22, 0, 0, 1724, 1725, 5, 38, 0, 0, 1725, 1726, 3, 98, 49, 0, 1726, 1730, 3, 102, 51, 0, 1727, 1729, 3, 100, 50, 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, 1762, 1, 0, 0, 0, 1732, 1730, 1, 0, 0, 0, 1733, 1734, 5, 22, 0, 0, 1734, 1735, 5, 39, 0, 0, 1735, 1736, 3, 98, 49, 0, 1736, 1740, 3, 102, 51, 0, 1737, 1739, 3, 100, 50, 0, 1738, 1737, 1, 0, 0, 0, 1739, 1742, 1, 0, 0, 0, 1740, 1738, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1762, 1, 0, 0, 0, 1742, 1740, 1, 0, 0, 0, 1743, 1744, 5, 19, 0, 0, 1744, 1745, 5, 38, 0, 0, 1745, 1762, 3, 98, 49, 0, 1746, 1747, 5, 19, 0, 0, 1747, 1748, 5, 39, 0, 0, 1748, 1762, 3, 98, 49, 0, 1749, 1750, 5, 47, 0, 0, 1750, 1751, 5, 49, 0, 0, 1751, 1762, 5, 499, 0, 0, 1752, 1753, 5, 47, 0, 0, 1753, 1754, 5, 394, 0, 0, 1754, 1762, 5, 499, 0, 0, 1755, 1756, 5, 46, 0, 0, 1756, 1757, 5, 41, 0, 0, 1757, 1762, 3, 108, 54, 0, 1758, 1759, 5, 19, 0, 0, 1759, 1760, 5, 41, 0, 0, 1760, 1762, 5, 503, 0, 0, 1761, 1705, 1, 0, 0, 0, 1761, 1708, 1, 0, 0, 0, 1761, 1711, 1, 0, 0, 0, 1761, 1717, 1, 0, 0, 0, 1761, 1723, 1, 0, 0, 0, 1761, 1733, 1, 0, 0, 0, 1761, 1743, 1, 0, 0, 0, 1761, 1746, 1, 0, 0, 0, 1761, 1749, 1, 0, 0, 0, 1761, 1752, 1, 0, 0, 0, 1761, 1755, 1, 0, 0, 0, 1761, 1758, 1, 0, 0, 0, 1762, 125, 1, 0, 0, 0, 1763, 1764, 5, 47, 0, 0, 1764, 1765, 5, 52, 0, 0, 1765, 1776, 3, 122, 61, 0, 1766, 1767, 5, 47, 0, 0, 1767, 1768, 5, 42, 0, 0, 1768, 1776, 7, 8, 0, 0, 1769, 1770, 5, 47, 0, 0, 1770, 1771, 5, 50, 0, 0, 1771, 1776, 7, 9, 0, 0, 1772, 1773, 5, 47, 0, 0, 1773, 1774, 5, 394, 0, 0, 1774, 1776, 5, 499, 0, 0, 1775, 1763, 1, 0, 0, 0, 1775, 1766, 1, 0, 0, 0, 1775, 1769, 1, 0, 0, 0, 1775, 1772, 1, 0, 0, 0, 1776, 127, 1, 0, 0, 0, 1777, 1778, 5, 46, 0, 0, 1778, 1779, 5, 406, 0, 0, 1779, 1782, 5, 503, 0, 0, 1780, 1781, 5, 186, 0, 0, 1781, 1783, 5, 499, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, 1783, 1, 0, 0, 0, 1783, 1796, 1, 0, 0, 0, 1784, 1785, 5, 20, 0, 0, 1785, 1786, 5, 406, 0, 0, 1786, 1787, 5, 503, 0, 0, 1787, 1788, 5, 411, 0, 0, 1788, 1796, 5, 503, 0, 0, 1789, 1790, 5, 19, 0, 0, 1790, 1791, 5, 406, 0, 0, 1791, 1796, 5, 503, 0, 0, 1792, 1793, 5, 47, 0, 0, 1793, 1794, 5, 394, 0, 0, 1794, 1796, 5, 499, 0, 0, 1795, 1777, 1, 0, 0, 0, 1795, 1784, 1, 0, 0, 0, 1795, 1789, 1, 0, 0, 0, 1795, 1792, 1, 0, 0, 0, 1796, 129, 1, 0, 0, 0, 1797, 1798, 5, 46, 0, 0, 1798, 1799, 5, 33, 0, 0, 1799, 1802, 3, 684, 342, 0, 1800, 1801, 5, 48, 0, 0, 1801, 1803, 5, 501, 0, 0, 1802, 1800, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1811, 1, 0, 0, 0, 1804, 1805, 5, 19, 0, 0, 1805, 1806, 5, 33, 0, 0, 1806, 1811, 3, 684, 342, 0, 1807, 1808, 5, 47, 0, 0, 1808, 1809, 5, 394, 0, 0, 1809, 1811, 5, 499, 0, 0, 1810, 1797, 1, 0, 0, 0, 1810, 1804, 1, 0, 0, 0, 1810, 1807, 1, 0, 0, 0, 1811, 131, 1, 0, 0, 0, 1812, 1813, 5, 29, 0, 0, 1813, 1815, 5, 503, 0, 0, 1814, 1816, 3, 134, 67, 0, 1815, 1814, 1, 0, 0, 0, 1815, 1816, 1, 0, 0, 0, 1816, 133, 1, 0, 0, 0, 1817, 1819, 3, 136, 68, 0, 1818, 1817, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 135, 1, 0, 0, 0, 1822, 1823, 5, 394, 0, 0, 1823, 1827, 5, 499, 0, 0, 1824, 1825, 5, 215, 0, 0, 1825, 1827, 5, 499, 0, 0, 1826, 1822, 1, 0, 0, 0, 1826, 1824, 1, 0, 0, 0, 1827, 137, 1, 0, 0, 0, 1828, 1829, 5, 28, 0, 0, 1829, 1830, 3, 684, 342, 0, 1830, 1831, 5, 485, 0, 0, 1831, 1832, 3, 140, 70, 0, 1832, 1834, 5, 486, 0, 0, 1833, 1835, 3, 146, 73, 0, 1834, 1833, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, 1835, 139, 1, 0, 0, 0, 1836, 1841, 3, 142, 71, 0, 1837, 1838, 5, 483, 0, 0, 1838, 1840, 3, 142, 71, 0, 1839, 1837, 1, 0, 0, 0, 1840, 1843, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 141, 1, 0, 0, 0, 1843, 1841, 1, 0, 0, 0, 1844, 1846, 3, 694, 347, 0, 1845, 1844, 1, 0, 0, 0, 1845, 1846, 1, 0, 0, 0, 1846, 1847, 1, 0, 0, 0, 1847, 1852, 3, 144, 72, 0, 1848, 1850, 5, 186, 0, 0, 1849, 1848, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1851, 1, 0, 0, 0, 1851, 1853, 5, 499, 0, 0, 1852, 1849, 1, 0, 0, 0, 1852, 1853, 1, 0, 0, 0, 1853, 143, 1, 0, 0, 0, 1854, 1870, 5, 503, 0, 0, 1855, 1870, 5, 505, 0, 0, 1856, 1870, 3, 706, 353, 0, 1857, 1870, 5, 307, 0, 0, 1858, 1870, 5, 308, 0, 0, 1859, 1870, 5, 338, 0, 0, 1860, 1870, 5, 337, 0, 0, 1861, 1870, 5, 313, 0, 0, 1862, 1870, 5, 332, 0, 0, 1863, 1870, 5, 333, 0, 0, 1864, 1870, 5, 334, 0, 0, 1865, 1870, 5, 335, 0, 0, 1866, 1870, 5, 26, 0, 0, 1867, 1870, 5, 339, 0, 0, 1868, 1870, 5, 361, 0, 0, 1869, 1854, 1, 0, 0, 0, 1869, 1855, 1, 0, 0, 0, 1869, 1856, 1, 0, 0, 0, 1869, 1857, 1, 0, 0, 0, 1869, 1858, 1, 0, 0, 0, 1869, 1859, 1, 0, 0, 0, 1869, 1860, 1, 0, 0, 0, 1869, 1861, 1, 0, 0, 0, 1869, 1862, 1, 0, 0, 0, 1869, 1863, 1, 0, 0, 0, 1869, 1864, 1, 0, 0, 0, 1869, 1865, 1, 0, 0, 0, 1869, 1866, 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1869, 1868, 1, 0, 0, 0, 1870, 145, 1, 0, 0, 0, 1871, 1873, 3, 148, 74, 0, 1872, 1871, 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 1872, 1, 0, 0, 0, 1874, 1875, 1, 0, 0, 0, 1875, 147, 1, 0, 0, 0, 1876, 1877, 5, 394, 0, 0, 1877, 1878, 5, 499, 0, 0, 1878, 149, 1, 0, 0, 0, 1879, 1880, 5, 293, 0, 0, 1880, 1881, 5, 295, 0, 0, 1881, 1882, 3, 684, 342, 0, 1882, 1883, 5, 414, 0, 0, 1883, 1884, 3, 684, 342, 0, 1884, 1885, 3, 152, 76, 0, 1885, 151, 1, 0, 0, 0, 1886, 1887, 5, 302, 0, 0, 1887, 1888, 3, 646, 323, 0, 1888, 1889, 5, 294, 0, 0, 1889, 1890, 5, 499, 0, 0, 1890, 1914, 1, 0, 0, 0, 1891, 1892, 5, 296, 0, 0, 1892, 1893, 3, 156, 78, 0, 1893, 1894, 5, 294, 0, 0, 1894, 1895, 5, 499, 0, 0, 1895, 1914, 1, 0, 0, 0, 1896, 1897, 5, 289, 0, 0, 1897, 1898, 3, 158, 79, 0, 1898, 1899, 5, 294, 0, 0, 1899, 1900, 5, 499, 0, 0, 1900, 1914, 1, 0, 0, 0, 1901, 1902, 5, 299, 0, 0, 1902, 1903, 3, 156, 78, 0, 1903, 1904, 3, 154, 77, 0, 1904, 1905, 5, 294, 0, 0, 1905, 1906, 5, 499, 0, 0, 1906, 1914, 1, 0, 0, 0, 1907, 1908, 5, 300, 0, 0, 1908, 1909, 3, 156, 78, 0, 1909, 1910, 5, 499, 0, 0, 1910, 1911, 5, 294, 0, 0, 1911, 1912, 5, 499, 0, 0, 1912, 1914, 1, 0, 0, 0, 1913, 1886, 1, 0, 0, 0, 1913, 1891, 1, 0, 0, 0, 1913, 1896, 1, 0, 0, 0, 1913, 1901, 1, 0, 0, 0, 1913, 1907, 1, 0, 0, 0, 1914, 153, 1, 0, 0, 0, 1915, 1916, 5, 285, 0, 0, 1916, 1917, 3, 688, 344, 0, 1917, 1918, 5, 280, 0, 0, 1918, 1919, 3, 688, 344, 0, 1919, 1929, 1, 0, 0, 0, 1920, 1921, 5, 473, 0, 0, 1921, 1929, 3, 688, 344, 0, 1922, 1923, 5, 470, 0, 0, 1923, 1929, 3, 688, 344, 0, 1924, 1925, 5, 474, 0, 0, 1925, 1929, 3, 688, 344, 0, 1926, 1927, 5, 471, 0, 0, 1927, 1929, 3, 688, 344, 0, 1928, 1915, 1, 0, 0, 0, 1928, 1920, 1, 0, 0, 0, 1928, 1922, 1, 0, 0, 0, 1928, 1924, 1, 0, 0, 0, 1928, 1926, 1, 0, 0, 0, 1929, 155, 1, 0, 0, 0, 1930, 1935, 5, 503, 0, 0, 1931, 1932, 5, 478, 0, 0, 1932, 1934, 5, 503, 0, 0, 1933, 1931, 1, 0, 0, 0, 1934, 1937, 1, 0, 0, 0, 1935, 1933, 1, 0, 0, 0, 1935, 1936, 1, 0, 0, 0, 1936, 157, 1, 0, 0, 0, 1937, 1935, 1, 0, 0, 0, 1938, 1943, 3, 156, 78, 0, 1939, 1940, 5, 483, 0, 0, 1940, 1942, 3, 156, 78, 0, 1941, 1939, 1, 0, 0, 0, 1942, 1945, 1, 0, 0, 0, 1943, 1941, 1, 0, 0, 0, 1943, 1944, 1, 0, 0, 0, 1944, 159, 1, 0, 0, 0, 1945, 1943, 1, 0, 0, 0, 1946, 1947, 5, 30, 0, 0, 1947, 1948, 3, 684, 342, 0, 1948, 1950, 5, 485, 0, 0, 1949, 1951, 3, 172, 86, 0, 1950, 1949, 1, 0, 0, 0, 1950, 1951, 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 1954, 5, 486, 0, 0, 1953, 1955, 3, 178, 89, 0, 1954, 1953, 1, 0, 0, 0, 1954, 1955, 1, 0, 0, 0, 1955, 1957, 1, 0, 0, 0, 1956, 1958, 3, 180, 90, 0, 1957, 1956, 1, 0, 0, 0, 1957, 1958, 1, 0, 0, 0, 1958, 1959, 1, 0, 0, 0, 1959, 1960, 5, 95, 0, 0, 1960, 1961, 3, 184, 92, 0, 1961, 1963, 5, 82, 0, 0, 1962, 1964, 5, 482, 0, 0, 1963, 1962, 1, 0, 0, 0, 1963, 1964, 1, 0, 0, 0, 1964, 1966, 1, 0, 0, 0, 1965, 1967, 5, 478, 0, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 161, 1, 0, 0, 0, 1968, 1969, 5, 113, 0, 0, 1969, 1970, 5, 114, 0, 0, 1970, 1971, 3, 684, 342, 0, 1971, 1973, 5, 485, 0, 0, 1972, 1974, 3, 164, 82, 0, 1973, 1972, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1977, 5, 486, 0, 0, 1976, 1978, 3, 168, 84, 0, 1977, 1976, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1980, 1, 0, 0, 0, 1979, 1981, 3, 170, 85, 0, 1980, 1979, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, 0, 1981, 1982, 1, 0, 0, 0, 1982, 1983, 5, 75, 0, 0, 1983, 1985, 5, 500, 0, 0, 1984, 1986, 5, 482, 0, 0, 1985, 1984, 1, 0, 0, 0, 1985, 1986, 1, 0, 0, 0, 1986, 163, 1, 0, 0, 0, 1987, 1992, 3, 166, 83, 0, 1988, 1989, 5, 483, 0, 0, 1989, 1991, 3, 166, 83, 0, 1990, 1988, 1, 0, 0, 0, 1991, 1994, 1, 0, 0, 0, 1992, 1990, 1, 0, 0, 0, 1992, 1993, 1, 0, 0, 0, 1993, 165, 1, 0, 0, 0, 1994, 1992, 1, 0, 0, 0, 1995, 1996, 3, 176, 88, 0, 1996, 1997, 5, 491, 0, 0, 1997, 1999, 3, 102, 51, 0, 1998, 2000, 5, 7, 0, 0, 1999, 1998, 1, 0, 0, 0, 1999, 2000, 1, 0, 0, 0, 2000, 167, 1, 0, 0, 0, 2001, 2002, 5, 76, 0, 0, 2002, 2003, 3, 102, 51, 0, 2003, 169, 1, 0, 0, 0, 2004, 2005, 5, 358, 0, 0, 2005, 2006, 5, 75, 0, 0, 2006, 2007, 5, 499, 0, 0, 2007, 2008, 5, 284, 0, 0, 2008, 2009, 5, 499, 0, 0, 2009, 171, 1, 0, 0, 0, 2010, 2015, 3, 174, 87, 0, 2011, 2012, 5, 483, 0, 0, 2012, 2014, 3, 174, 87, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2017, 1, 0, 0, 0, 2015, 2013, 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 173, 1, 0, 0, 0, 2017, 2015, 1, 0, 0, 0, 2018, 2021, 3, 176, 88, 0, 2019, 2021, 5, 502, 0, 0, 2020, 2018, 1, 0, 0, 0, 2020, 2019, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 2023, 5, 491, 0, 0, 2023, 2024, 3, 102, 51, 0, 2024, 175, 1, 0, 0, 0, 2025, 2029, 5, 503, 0, 0, 2026, 2029, 5, 505, 0, 0, 2027, 2029, 3, 706, 353, 0, 2028, 2025, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2028, 2027, 1, 0, 0, 0, 2029, 177, 1, 0, 0, 0, 2030, 2031, 5, 76, 0, 0, 2031, 2034, 3, 102, 51, 0, 2032, 2033, 5, 75, 0, 0, 2033, 2035, 5, 502, 0, 0, 2034, 2032, 1, 0, 0, 0, 2034, 2035, 1, 0, 0, 0, 2035, 179, 1, 0, 0, 0, 2036, 2038, 3, 182, 91, 0, 2037, 2036, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 2037, 1, 0, 0, 0, 2039, 2040, 1, 0, 0, 0, 2040, 181, 1, 0, 0, 0, 2041, 2042, 5, 215, 0, 0, 2042, 2046, 5, 499, 0, 0, 2043, 2044, 5, 394, 0, 0, 2044, 2046, 5, 499, 0, 0, 2045, 2041, 1, 0, 0, 0, 2045, 2043, 1, 0, 0, 0, 2046, 183, 1, 0, 0, 0, 2047, 2049, 3, 186, 93, 0, 2048, 2047, 1, 0, 0, 0, 2049, 2052, 1, 0, 0, 0, 2050, 2048, 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, 185, 1, 0, 0, 0, 2052, 2050, 1, 0, 0, 0, 2053, 2055, 3, 696, 348, 0, 2054, 2053, 1, 0, 0, 0, 2055, 2058, 1, 0, 0, 0, 2056, 2054, 1, 0, 0, 0, 2056, 2057, 1, 0, 0, 0, 2057, 2059, 1, 0, 0, 0, 2058, 2056, 1, 0, 0, 0, 2059, 2061, 3, 188, 94, 0, 2060, 2062, 5, 482, 0, 0, 2061, 2060, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0, 2062, 2374, 1, 0, 0, 0, 2063, 2065, 3, 696, 348, 0, 2064, 2063, 1, 0, 0, 0, 2065, 2068, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, 0, 2066, 2067, 1, 0, 0, 0, 2067, 2069, 1, 0, 0, 0, 2068, 2066, 1, 0, 0, 0, 2069, 2071, 3, 190, 95, 0, 2070, 2072, 5, 482, 0, 0, 2071, 2070, 1, 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2374, 1, 0, 0, 0, 2073, 2075, 3, 696, 348, 0, 2074, 2073, 1, 0, 0, 0, 2075, 2078, 1, 0, 0, 0, 2076, 2074, 1, 0, 0, 0, 2076, 2077, 1, 0, 0, 0, 2077, 2079, 1, 0, 0, 0, 2078, 2076, 1, 0, 0, 0, 2079, 2081, 3, 294, 147, 0, 2080, 2082, 5, 482, 0, 0, 2081, 2080, 1, 0, 0, 0, 2081, 2082, 1, 0, 0, 0, 2082, 2374, 1, 0, 0, 0, 2083, 2085, 3, 696, 348, 0, 2084, 2083, 1, 0, 0, 0, 2085, 2088, 1, 0, 0, 0, 2086, 2084, 1, 0, 0, 0, 2086, 2087, 1, 0, 0, 0, 2087, 2089, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2089, 2091, 3, 192, 96, 0, 2090, 2092, 5, 482, 0, 0, 2091, 2090, 1, 0, 0, 0, 2091, 2092, 1, 0, 0, 0, 2092, 2374, 1, 0, 0, 0, 2093, 2095, 3, 696, 348, 0, 2094, 2093, 1, 0, 0, 0, 2095, 2098, 1, 0, 0, 0, 2096, 2094, 1, 0, 0, 0, 2096, 2097, 1, 0, 0, 0, 2097, 2099, 1, 0, 0, 0, 2098, 2096, 1, 0, 0, 0, 2099, 2101, 3, 194, 97, 0, 2100, 2102, 5, 482, 0, 0, 2101, 2100, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2374, 1, 0, 0, 0, 2103, 2105, 3, 696, 348, 0, 2104, 2103, 1, 0, 0, 0, 2105, 2108, 1, 0, 0, 0, 2106, 2104, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2109, 1, 0, 0, 0, 2108, 2106, 1, 0, 0, 0, 2109, 2111, 3, 198, 99, 0, 2110, 2112, 5, 482, 0, 0, 2111, 2110, 1, 0, 0, 0, 2111, 2112, 1, 0, 0, 0, 2112, 2374, 1, 0, 0, 0, 2113, 2115, 3, 696, 348, 0, 2114, 2113, 1, 0, 0, 0, 2115, 2118, 1, 0, 0, 0, 2116, 2114, 1, 0, 0, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2119, 1, 0, 0, 0, 2118, 2116, 1, 0, 0, 0, 2119, 2121, 3, 200, 100, 0, 2120, 2122, 5, 482, 0, 0, 2121, 2120, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 2374, 1, 0, 0, 0, 2123, 2125, 3, 696, 348, 0, 2124, 2123, 1, 0, 0, 0, 2125, 2128, 1, 0, 0, 0, 2126, 2124, 1, 0, 0, 0, 2126, 2127, 1, 0, 0, 0, 2127, 2129, 1, 0, 0, 0, 2128, 2126, 1, 0, 0, 0, 2129, 2131, 3, 202, 101, 0, 2130, 2132, 5, 482, 0, 0, 2131, 2130, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2374, 1, 0, 0, 0, 2133, 2135, 3, 696, 348, 0, 2134, 2133, 1, 0, 0, 0, 2135, 2138, 1, 0, 0, 0, 2136, 2134, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2139, 1, 0, 0, 0, 2138, 2136, 1, 0, 0, 0, 2139, 2141, 3, 204, 102, 0, 2140, 2142, 5, 482, 0, 0, 2141, 2140, 1, 0, 0, 0, 2141, 2142, 1, 0, 0, 0, 2142, 2374, 1, 0, 0, 0, 2143, 2145, 3, 696, 348, 0, 2144, 2143, 1, 0, 0, 0, 2145, 2148, 1, 0, 0, 0, 2146, 2144, 1, 0, 0, 0, 2146, 2147, 1, 0, 0, 0, 2147, 2149, 1, 0, 0, 0, 2148, 2146, 1, 0, 0, 0, 2149, 2151, 3, 210, 105, 0, 2150, 2152, 5, 482, 0, 0, 2151, 2150, 1, 0, 0, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2374, 1, 0, 0, 0, 2153, 2155, 3, 696, 348, 0, 2154, 2153, 1, 0, 0, 0, 2155, 2158, 1, 0, 0, 0, 2156, 2154, 1, 0, 0, 0, 2156, 2157, 1, 0, 0, 0, 2157, 2159, 1, 0, 0, 0, 2158, 2156, 1, 0, 0, 0, 2159, 2161, 3, 212, 106, 0, 2160, 2162, 5, 482, 0, 0, 2161, 2160, 1, 0, 0, 0, 2161, 2162, 1, 0, 0, 0, 2162, 2374, 1, 0, 0, 0, 2163, 2165, 3, 696, 348, 0, 2164, 2163, 1, 0, 0, 0, 2165, 2168, 1, 0, 0, 0, 2166, 2164, 1, 0, 0, 0, 2166, 2167, 1, 0, 0, 0, 2167, 2169, 1, 0, 0, 0, 2168, 2166, 1, 0, 0, 0, 2169, 2171, 3, 214, 107, 0, 2170, 2172, 5, 482, 0, 0, 2171, 2170, 1, 0, 0, 0, 2171, 2172, 1, 0, 0, 0, 2172, 2374, 1, 0, 0, 0, 2173, 2175, 3, 696, 348, 0, 2174, 2173, 1, 0, 0, 0, 2175, 2178, 1, 0, 0, 0, 2176, 2174, 1, 0, 0, 0, 2176, 2177, 1, 0, 0, 0, 2177, 2179, 1, 0, 0, 0, 2178, 2176, 1, 0, 0, 0, 2179, 2181, 3, 216, 108, 0, 2180, 2182, 5, 482, 0, 0, 2181, 2180, 1, 0, 0, 0, 2181, 2182, 1, 0, 0, 0, 2182, 2374, 1, 0, 0, 0, 2183, 2185, 3, 696, 348, 0, 2184, 2183, 1, 0, 0, 0, 2185, 2188, 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2186, 2187, 1, 0, 0, 0, 2187, 2189, 1, 0, 0, 0, 2188, 2186, 1, 0, 0, 0, 2189, 2191, 3, 218, 109, 0, 2190, 2192, 5, 482, 0, 0, 2191, 2190, 1, 0, 0, 0, 2191, 2192, 1, 0, 0, 0, 2192, 2374, 1, 0, 0, 0, 2193, 2195, 3, 696, 348, 0, 2194, 2193, 1, 0, 0, 0, 2195, 2198, 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2196, 2197, 1, 0, 0, 0, 2197, 2199, 1, 0, 0, 0, 2198, 2196, 1, 0, 0, 0, 2199, 2201, 3, 220, 110, 0, 2200, 2202, 5, 482, 0, 0, 2201, 2200, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2374, 1, 0, 0, 0, 2203, 2205, 3, 696, 348, 0, 2204, 2203, 1, 0, 0, 0, 2205, 2208, 1, 0, 0, 0, 2206, 2204, 1, 0, 0, 0, 2206, 2207, 1, 0, 0, 0, 2207, 2209, 1, 0, 0, 0, 2208, 2206, 1, 0, 0, 0, 2209, 2211, 3, 222, 111, 0, 2210, 2212, 5, 482, 0, 0, 2211, 2210, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2374, 1, 0, 0, 0, 2213, 2215, 3, 696, 348, 0, 2214, 2213, 1, 0, 0, 0, 2215, 2218, 1, 0, 0, 0, 2216, 2214, 1, 0, 0, 0, 2216, 2217, 1, 0, 0, 0, 2217, 2219, 1, 0, 0, 0, 2218, 2216, 1, 0, 0, 0, 2219, 2221, 3, 224, 112, 0, 2220, 2222, 5, 482, 0, 0, 2221, 2220, 1, 0, 0, 0, 2221, 2222, 1, 0, 0, 0, 2222, 2374, 1, 0, 0, 0, 2223, 2225, 3, 696, 348, 0, 2224, 2223, 1, 0, 0, 0, 2225, 2228, 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2229, 1, 0, 0, 0, 2228, 2226, 1, 0, 0, 0, 2229, 2231, 3, 236, 118, 0, 2230, 2232, 5, 482, 0, 0, 2231, 2230, 1, 0, 0, 0, 2231, 2232, 1, 0, 0, 0, 2232, 2374, 1, 0, 0, 0, 2233, 2235, 3, 696, 348, 0, 2234, 2233, 1, 0, 0, 0, 2235, 2238, 1, 0, 0, 0, 2236, 2234, 1, 0, 0, 0, 2236, 2237, 1, 0, 0, 0, 2237, 2239, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2239, 2241, 3, 238, 119, 0, 2240, 2242, 5, 482, 0, 0, 2241, 2240, 1, 0, 0, 0, 2241, 2242, 1, 0, 0, 0, 2242, 2374, 1, 0, 0, 0, 2243, 2245, 3, 696, 348, 0, 2244, 2243, 1, 0, 0, 0, 2245, 2248, 1, 0, 0, 0, 2246, 2244, 1, 0, 0, 0, 2246, 2247, 1, 0, 0, 0, 2247, 2249, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2249, 2251, 3, 240, 120, 0, 2250, 2252, 5, 482, 0, 0, 2251, 2250, 1, 0, 0, 0, 2251, 2252, 1, 0, 0, 0, 2252, 2374, 1, 0, 0, 0, 2253, 2255, 3, 696, 348, 0, 2254, 2253, 1, 0, 0, 0, 2255, 2258, 1, 0, 0, 0, 2256, 2254, 1, 0, 0, 0, 2256, 2257, 1, 0, 0, 0, 2257, 2259, 1, 0, 0, 0, 2258, 2256, 1, 0, 0, 0, 2259, 2261, 3, 242, 121, 0, 2260, 2262, 5, 482, 0, 0, 2261, 2260, 1, 0, 0, 0, 2261, 2262, 1, 0, 0, 0, 2262, 2374, 1, 0, 0, 0, 2263, 2265, 3, 696, 348, 0, 2264, 2263, 1, 0, 0, 0, 2265, 2268, 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2266, 2267, 1, 0, 0, 0, 2267, 2269, 1, 0, 0, 0, 2268, 2266, 1, 0, 0, 0, 2269, 2271, 3, 248, 124, 0, 2270, 2272, 5, 482, 0, 0, 2271, 2270, 1, 0, 0, 0, 2271, 2272, 1, 0, 0, 0, 2272, 2374, 1, 0, 0, 0, 2273, 2275, 3, 696, 348, 0, 2274, 2273, 1, 0, 0, 0, 2275, 2278, 1, 0, 0, 0, 2276, 2274, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 2279, 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2279, 2281, 3, 254, 127, 0, 2280, 2282, 5, 482, 0, 0, 2281, 2280, 1, 0, 0, 0, 2281, 2282, 1, 0, 0, 0, 2282, 2374, 1, 0, 0, 0, 2283, 2285, 3, 696, 348, 0, 2284, 2283, 1, 0, 0, 0, 2285, 2288, 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2286, 2287, 1, 0, 0, 0, 2287, 2289, 1, 0, 0, 0, 2288, 2286, 1, 0, 0, 0, 2289, 2291, 3, 256, 128, 0, 2290, 2292, 5, 482, 0, 0, 2291, 2290, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, 2374, 1, 0, 0, 0, 2293, 2295, 3, 696, 348, 0, 2294, 2293, 1, 0, 0, 0, 2295, 2298, 1, 0, 0, 0, 2296, 2294, 1, 0, 0, 0, 2296, 2297, 1, 0, 0, 0, 2297, 2299, 1, 0, 0, 0, 2298, 2296, 1, 0, 0, 0, 2299, 2301, 3, 258, 129, 0, 2300, 2302, 5, 482, 0, 0, 2301, 2300, 1, 0, 0, 0, 2301, 2302, 1, 0, 0, 0, 2302, 2374, 1, 0, 0, 0, 2303, 2305, 3, 696, 348, 0, 2304, 2303, 1, 0, 0, 0, 2305, 2308, 1, 0, 0, 0, 2306, 2304, 1, 0, 0, 0, 2306, 2307, 1, 0, 0, 0, 2307, 2309, 1, 0, 0, 0, 2308, 2306, 1, 0, 0, 0, 2309, 2311, 3, 260, 130, 0, 2310, 2312, 5, 482, 0, 0, 2311, 2310, 1, 0, 0, 0, 2311, 2312, 1, 0, 0, 0, 2312, 2374, 1, 0, 0, 0, 2313, 2315, 3, 696, 348, 0, 2314, 2313, 1, 0, 0, 0, 2315, 2318, 1, 0, 0, 0, 2316, 2314, 1, 0, 0, 0, 2316, 2317, 1, 0, 0, 0, 2317, 2319, 1, 0, 0, 0, 2318, 2316, 1, 0, 0, 0, 2319, 2321, 3, 282, 141, 0, 2320, 2322, 5, 482, 0, 0, 2321, 2320, 1, 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2374, 1, 0, 0, 0, 2323, 2325, 3, 696, 348, 0, 2324, 2323, 1, 0, 0, 0, 2325, 2328, 1, 0, 0, 0, 2326, 2324, 1, 0, 0, 0, 2326, 2327, 1, 0, 0, 0, 2327, 2329, 1, 0, 0, 0, 2328, 2326, 1, 0, 0, 0, 2329, 2331, 3, 290, 145, 0, 2330, 2332, 5, 482, 0, 0, 2331, 2330, 1, 0, 0, 0, 2331, 2332, 1, 0, 0, 0, 2332, 2374, 1, 0, 0, 0, 2333, 2335, 3, 696, 348, 0, 2334, 2333, 1, 0, 0, 0, 2335, 2338, 1, 0, 0, 0, 2336, 2334, 1, 0, 0, 0, 2336, 2337, 1, 0, 0, 0, 2337, 2339, 1, 0, 0, 0, 2338, 2336, 1, 0, 0, 0, 2339, 2341, 3, 296, 148, 0, 2340, 2342, 5, 482, 0, 0, 2341, 2340, 1, 0, 0, 0, 2341, 2342, 1, 0, 0, 0, 2342, 2374, 1, 0, 0, 0, 2343, 2345, 3, 696, 348, 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, 2351, 3, 298, 149, 0, 2350, 2352, 5, 482, 0, 0, 2351, 2350, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2374, 1, 0, 0, 0, 2353, 2355, 3, 696, 348, 0, 2354, 2353, 1, 0, 0, 0, 2355, 2358, 1, 0, 0, 0, 2356, 2354, 1, 0, 0, 0, 2356, 2357, 1, 0, 0, 0, 2357, 2359, 1, 0, 0, 0, 2358, 2356, 1, 0, 0, 0, 2359, 2361, 3, 262, 131, 0, 2360, 2362, 5, 482, 0, 0, 2361, 2360, 1, 0, 0, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2374, 1, 0, 0, 0, 2363, 2365, 3, 696, 348, 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, 2371, 3, 264, 132, 0, 2370, 2372, 5, 482, 0, 0, 2371, 2370, 1, 0, 0, 0, 2371, 2372, 1, 0, 0, 0, 2372, 2374, 1, 0, 0, 0, 2373, 2056, 1, 0, 0, 0, 2373, 2066, 1, 0, 0, 0, 2373, 2076, 1, 0, 0, 0, 2373, 2086, 1, 0, 0, 0, 2373, 2096, 1, 0, 0, 0, 2373, 2106, 1, 0, 0, 0, 2373, 2116, 1, 0, 0, 0, 2373, 2126, 1, 0, 0, 0, 2373, 2136, 1, 0, 0, 0, 2373, 2146, 1, 0, 0, 0, 2373, 2156, 1, 0, 0, 0, 2373, 2166, 1, 0, 0, 0, 2373, 2176, 1, 0, 0, 0, 2373, 2186, 1, 0, 0, 0, 2373, 2196, 1, 0, 0, 0, 2373, 2206, 1, 0, 0, 0, 2373, 2216, 1, 0, 0, 0, 2373, 2226, 1, 0, 0, 0, 2373, 2236, 1, 0, 0, 0, 2373, 2246, 1, 0, 0, 0, 2373, 2256, 1, 0, 0, 0, 2373, 2266, 1, 0, 0, 0, 2373, 2276, 1, 0, 0, 0, 2373, 2286, 1, 0, 0, 0, 2373, 2296, 1, 0, 0, 0, 2373, 2306, 1, 0, 0, 0, 2373, 2316, 1, 0, 0, 0, 2373, 2326, 1, 0, 0, 0, 2373, 2336, 1, 0, 0, 0, 2373, 2346, 1, 0, 0, 0, 2373, 2356, 1, 0, 0, 0, 2373, 2366, 1, 0, 0, 0, 2374, 187, 1, 0, 0, 0, 2375, 2376, 5, 96, 0, 0, 2376, 2377, 5, 502, 0, 0, 2377, 2380, 3, 102, 51, 0, 2378, 2379, 5, 472, 0, 0, 2379, 2381, 3, 646, 323, 0, 2380, 2378, 1, 0, 0, 0, 2380, 2381, 1, 0, 0, 0, 2381, 189, 1, 0, 0, 0, 2382, 2385, 5, 47, 0, 0, 2383, 2386, 5, 502, 0, 0, 2384, 2386, 3, 196, 98, 0, 2385, 2383, 1, 0, 0, 0, 2385, 2384, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, 2387, 2388, 5, 472, 0, 0, 2388, 2389, 3, 646, 323, 0, 2389, 191, 1, 0, 0, 0, 2390, 2391, 5, 502, 0, 0, 2391, 2393, 5, 472, 0, 0, 2392, 2390, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2395, 5, 17, 0, 0, 2395, 2401, 3, 106, 53, 0, 2396, 2398, 5, 485, 0, 0, 2397, 2399, 3, 300, 150, 0, 2398, 2397, 1, 0, 0, 0, 2398, 2399, 1, 0, 0, 0, 2399, 2400, 1, 0, 0, 0, 2400, 2402, 5, 486, 0, 0, 2401, 2396, 1, 0, 0, 0, 2401, 2402, 1, 0, 0, 0, 2402, 2404, 1, 0, 0, 0, 2403, 2405, 3, 208, 104, 0, 2404, 2403, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 193, 1, 0, 0, 0, 2406, 2407, 5, 97, 0, 0, 2407, 2413, 5, 502, 0, 0, 2408, 2410, 5, 485, 0, 0, 2409, 2411, 3, 300, 150, 0, 2410, 2409, 1, 0, 0, 0, 2410, 2411, 1, 0, 0, 0, 2411, 2412, 1, 0, 0, 0, 2412, 2414, 5, 486, 0, 0, 2413, 2408, 1, 0, 0, 0, 2413, 2414, 1, 0, 0, 0, 2414, 195, 1, 0, 0, 0, 2415, 2421, 5, 502, 0, 0, 2416, 2419, 7, 11, 0, 0, 2417, 2420, 5, 503, 0, 0, 2418, 2420, 3, 684, 342, 0, 2419, 2417, 1, 0, 0, 0, 2419, 2418, 1, 0, 0, 0, 2420, 2422, 1, 0, 0, 0, 2421, 2416, 1, 0, 0, 0, 2422, 2423, 1, 0, 0, 0, 2423, 2421, 1, 0, 0, 0, 2423, 2424, 1, 0, 0, 0, 2424, 197, 1, 0, 0, 0, 2425, 2426, 5, 100, 0, 0, 2426, 2429, 5, 502, 0, 0, 2427, 2428, 5, 137, 0, 0, 2428, 2430, 5, 118, 0, 0, 2429, 2427, 1, 0, 0, 0, 2429, 2430, 1, 0, 0, 0, 2430, 2432, 1, 0, 0, 0, 2431, 2433, 5, 384, 0, 0, 2432, 2431, 1, 0, 0, 0, 2432, 2433, 1, 0, 0, 0, 2433, 2435, 1, 0, 0, 0, 2434, 2436, 3, 208, 104, 0, 2435, 2434, 1, 0, 0, 0, 2435, 2436, 1, 0, 0, 0, 2436, 199, 1, 0, 0, 0, 2437, 2438, 5, 99, 0, 0, 2438, 2440, 5, 502, 0, 0, 2439, 2441, 3, 208, 104, 0, 2440, 2439, 1, 0, 0, 0, 2440, 2441, 1, 0, 0, 0, 2441, 201, 1, 0, 0, 0, 2442, 2443, 5, 101, 0, 0, 2443, 2445, 5, 502, 0, 0, 2444, 2446, 5, 384, 0, 0, 2445, 2444, 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 203, 1, 0, 0, 0, 2447, 2448, 5, 98, 0, 0, 2448, 2449, 5, 502, 0, 0, 2449, 2450, 5, 70, 0, 0, 2450, 2456, 3, 206, 103, 0, 2451, 2454, 5, 71, 0, 0, 2452, 2455, 3, 332, 166, 0, 2453, 2455, 3, 646, 323, 0, 2454, 2452, 1, 0, 0, 0, 2454, 2453, 1, 0, 0, 0, 2455, 2457, 1, 0, 0, 0, 2456, 2451, 1, 0, 0, 0, 2456, 2457, 1, 0, 0, 0, 2457, 2467, 1, 0, 0, 0, 2458, 2459, 5, 10, 0, 0, 2459, 2464, 3, 330, 165, 0, 2460, 2461, 5, 483, 0, 0, 2461, 2463, 3, 330, 165, 0, 2462, 2460, 1, 0, 0, 0, 2463, 2466, 1, 0, 0, 0, 2464, 2462, 1, 0, 0, 0, 2464, 2465, 1, 0, 0, 0, 2465, 2468, 1, 0, 0, 0, 2466, 2464, 1, 0, 0, 0, 2467, 2458, 1, 0, 0, 0, 2467, 2468, 1, 0, 0, 0, 2468, 2471, 1, 0, 0, 0, 2469, 2470, 5, 74, 0, 0, 2470, 2472, 3, 646, 323, 0, 2471, 2469, 1, 0, 0, 0, 2471, 2472, 1, 0, 0, 0, 2472, 2475, 1, 0, 0, 0, 2473, 2474, 5, 73, 0, 0, 2474, 2476, 3, 646, 323, 0, 2475, 2473, 1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 2478, 1, 0, 0, 0, 2477, 2479, 3, 208, 104, 0, 2478, 2477, 1, 0, 0, 0, 2478, 2479, 1, 0, 0, 0, 2479, 205, 1, 0, 0, 0, 2480, 2488, 3, 684, 342, 0, 2481, 2482, 5, 485, 0, 0, 2482, 2483, 3, 560, 280, 0, 2483, 2484, 5, 486, 0, 0, 2484, 2488, 1, 0, 0, 0, 2485, 2486, 5, 344, 0, 0, 2486, 2488, 5, 499, 0, 0, 2487, 2480, 1, 0, 0, 0, 2487, 2481, 1, 0, 0, 0, 2487, 2485, 1, 0, 0, 0, 2488, 207, 1, 0, 0, 0, 2489, 2490, 5, 92, 0, 0, 2490, 2491, 5, 297, 0, 0, 2491, 2510, 5, 107, 0, 0, 2492, 2493, 5, 92, 0, 0, 2493, 2494, 5, 297, 0, 0, 2494, 2510, 5, 101, 0, 0, 2495, 2496, 5, 92, 0, 0, 2496, 2497, 5, 297, 0, 0, 2497, 2498, 5, 487, 0, 0, 2498, 2499, 3, 184, 92, 0, 2499, 2500, 5, 488, 0, 0, 2500, 2510, 1, 0, 0, 0, 2501, 2502, 5, 92, 0, 0, 2502, 2503, 5, 297, 0, 0, 2503, 2504, 5, 420, 0, 0, 2504, 2505, 5, 101, 0, 0, 2505, 2506, 5, 487, 0, 0, 2506, 2507, 3, 184, 92, 0, 2507, 2508, 5, 488, 0, 0, 2508, 2510, 1, 0, 0, 0, 2509, 2489, 1, 0, 0, 0, 2509, 2492, 1, 0, 0, 0, 2509, 2495, 1, 0, 0, 0, 2509, 2501, 1, 0, 0, 0, 2510, 209, 1, 0, 0, 0, 2511, 2512, 5, 104, 0, 0, 2512, 2513, 3, 646, 323, 0, 2513, 2514, 5, 80, 0, 0, 2514, 2522, 3, 184, 92, 0, 2515, 2516, 5, 105, 0, 0, 2516, 2517, 3, 646, 323, 0, 2517, 2518, 5, 80, 0, 0, 2518, 2519, 3, 184, 92, 0, 2519, 2521, 1, 0, 0, 0, 2520, 2515, 1, 0, 0, 0, 2521, 2524, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2522, 2523, 1, 0, 0, 0, 2523, 2527, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2525, 2526, 5, 81, 0, 0, 2526, 2528, 3, 184, 92, 0, 2527, 2525, 1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2529, 1, 0, 0, 0, 2529, 2530, 5, 82, 0, 0, 2530, 2531, 5, 104, 0, 0, 2531, 211, 1, 0, 0, 0, 2532, 2533, 5, 102, 0, 0, 2533, 2534, 5, 502, 0, 0, 2534, 2537, 5, 284, 0, 0, 2535, 2538, 5, 502, 0, 0, 2536, 2538, 3, 196, 98, 0, 2537, 2535, 1, 0, 0, 0, 2537, 2536, 1, 0, 0, 0, 2538, 2539, 1, 0, 0, 0, 2539, 2540, 5, 95, 0, 0, 2540, 2541, 3, 184, 92, 0, 2541, 2542, 5, 82, 0, 0, 2542, 2543, 5, 102, 0, 0, 2543, 213, 1, 0, 0, 0, 2544, 2545, 5, 103, 0, 0, 2545, 2547, 3, 646, 323, 0, 2546, 2548, 5, 95, 0, 0, 2547, 2546, 1, 0, 0, 0, 2547, 2548, 1, 0, 0, 0, 2548, 2549, 1, 0, 0, 0, 2549, 2550, 3, 184, 92, 0, 2550, 2552, 5, 82, 0, 0, 2551, 2553, 5, 103, 0, 0, 2552, 2551, 1, 0, 0, 0, 2552, 2553, 1, 0, 0, 0, 2553, 215, 1, 0, 0, 0, 2554, 2555, 5, 107, 0, 0, 2555, 217, 1, 0, 0, 0, 2556, 2557, 5, 108, 0, 0, 2557, 219, 1, 0, 0, 0, 2558, 2560, 5, 109, 0, 0, 2559, 2561, 3, 646, 323, 0, 2560, 2559, 1, 0, 0, 0, 2560, 2561, 1, 0, 0, 0, 2561, 221, 1, 0, 0, 0, 2562, 2563, 5, 298, 0, 0, 2563, 2564, 5, 297, 0, 0, 2564, 223, 1, 0, 0, 0, 2565, 2567, 5, 111, 0, 0, 2566, 2568, 3, 226, 113, 0, 2567, 2566, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2571, 1, 0, 0, 0, 2569, 2570, 5, 117, 0, 0, 2570, 2572, 5, 499, 0, 0, 2571, 2569, 1, 0, 0, 0, 2571, 2572, 1, 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2575, 3, 646, 323, 0, 2574, 2576, 3, 232, 116, 0, 2575, 2574, 1, 0, 0, 0, 2575, 2576, 1, 0, 0, 0, 2576, 225, 1, 0, 0, 0, 2577, 2578, 7, 12, 0, 0, 2578, 227, 1, 0, 0, 0, 2579, 2580, 5, 137, 0, 0, 2580, 2581, 5, 485, 0, 0, 2581, 2586, 3, 230, 115, 0, 2582, 2583, 5, 483, 0, 0, 2583, 2585, 3, 230, 115, 0, 2584, 2582, 1, 0, 0, 0, 2585, 2588, 1, 0, 0, 0, 2586, 2584, 1, 0, 0, 0, 2586, 2587, 1, 0, 0, 0, 2587, 2589, 1, 0, 0, 0, 2588, 2586, 1, 0, 0, 0, 2589, 2590, 5, 486, 0, 0, 2590, 2594, 1, 0, 0, 0, 2591, 2592, 5, 360, 0, 0, 2592, 2594, 3, 690, 345, 0, 2593, 2579, 1, 0, 0, 0, 2593, 2591, 1, 0, 0, 0, 2594, 229, 1, 0, 0, 0, 2595, 2596, 5, 487, 0, 0, 2596, 2597, 5, 501, 0, 0, 2597, 2598, 5, 488, 0, 0, 2598, 2599, 5, 472, 0, 0, 2599, 2600, 3, 646, 323, 0, 2600, 231, 1, 0, 0, 0, 2601, 2602, 3, 228, 114, 0, 2602, 233, 1, 0, 0, 0, 2603, 2604, 3, 230, 115, 0, 2604, 235, 1, 0, 0, 0, 2605, 2606, 5, 502, 0, 0, 2606, 2608, 5, 472, 0, 0, 2607, 2605, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, 0, 2608, 2609, 1, 0, 0, 0, 2609, 2610, 5, 112, 0, 0, 2610, 2611, 5, 30, 0, 0, 2611, 2612, 3, 684, 342, 0, 2612, 2614, 5, 485, 0, 0, 2613, 2615, 3, 244, 122, 0, 2614, 2613, 1, 0, 0, 0, 2614, 2615, 1, 0, 0, 0, 2615, 2616, 1, 0, 0, 0, 2616, 2618, 5, 486, 0, 0, 2617, 2619, 3, 208, 104, 0, 2618, 2617, 1, 0, 0, 0, 2618, 2619, 1, 0, 0, 0, 2619, 237, 1, 0, 0, 0, 2620, 2621, 5, 502, 0, 0, 2621, 2623, 5, 472, 0, 0, 2622, 2620, 1, 0, 0, 0, 2622, 2623, 1, 0, 0, 0, 2623, 2624, 1, 0, 0, 0, 2624, 2625, 5, 112, 0, 0, 2625, 2626, 5, 113, 0, 0, 2626, 2627, 5, 114, 0, 0, 2627, 2628, 3, 684, 342, 0, 2628, 2630, 5, 485, 0, 0, 2629, 2631, 3, 244, 122, 0, 2630, 2629, 1, 0, 0, 0, 2630, 2631, 1, 0, 0, 0, 2631, 2632, 1, 0, 0, 0, 2632, 2634, 5, 486, 0, 0, 2633, 2635, 3, 208, 104, 0, 2634, 2633, 1, 0, 0, 0, 2634, 2635, 1, 0, 0, 0, 2635, 239, 1, 0, 0, 0, 2636, 2637, 5, 502, 0, 0, 2637, 2639, 5, 472, 0, 0, 2638, 2636, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2641, 5, 387, 0, 0, 2641, 2642, 5, 344, 0, 0, 2642, 2643, 5, 345, 0, 0, 2643, 2650, 3, 684, 342, 0, 2644, 2648, 5, 164, 0, 0, 2645, 2649, 5, 499, 0, 0, 2646, 2649, 5, 500, 0, 0, 2647, 2649, 3, 646, 323, 0, 2648, 2645, 1, 0, 0, 0, 2648, 2646, 1, 0, 0, 0, 2648, 2647, 1, 0, 0, 0, 2649, 2651, 1, 0, 0, 0, 2650, 2644, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2657, 1, 0, 0, 0, 2652, 2654, 5, 485, 0, 0, 2653, 2655, 3, 244, 122, 0, 2654, 2653, 1, 0, 0, 0, 2654, 2655, 1, 0, 0, 0, 2655, 2656, 1, 0, 0, 0, 2656, 2658, 5, 486, 0, 0, 2657, 2652, 1, 0, 0, 0, 2657, 2658, 1, 0, 0, 0, 2658, 2665, 1, 0, 0, 0, 2659, 2660, 5, 343, 0, 0, 2660, 2662, 5, 485, 0, 0, 2661, 2663, 3, 244, 122, 0, 2662, 2661, 1, 0, 0, 0, 2662, 2663, 1, 0, 0, 0, 2663, 2664, 1, 0, 0, 0, 2664, 2666, 5, 486, 0, 0, 2665, 2659, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2668, 1, 0, 0, 0, 2667, 2669, 3, 208, 104, 0, 2668, 2667, 1, 0, 0, 0, 2668, 2669, 1, 0, 0, 0, 2669, 241, 1, 0, 0, 0, 2670, 2671, 5, 502, 0, 0, 2671, 2673, 5, 472, 0, 0, 2672, 2670, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, 2674, 1, 0, 0, 0, 2674, 2675, 5, 112, 0, 0, 2675, 2676, 5, 26, 0, 0, 2676, 2677, 5, 114, 0, 0, 2677, 2678, 3, 684, 342, 0, 2678, 2680, 5, 485, 0, 0, 2679, 2681, 3, 244, 122, 0, 2680, 2679, 1, 0, 0, 0, 2680, 2681, 1, 0, 0, 0, 2681, 2682, 1, 0, 0, 0, 2682, 2684, 5, 486, 0, 0, 2683, 2685, 3, 208, 104, 0, 2684, 2683, 1, 0, 0, 0, 2684, 2685, 1, 0, 0, 0, 2685, 243, 1, 0, 0, 0, 2686, 2691, 3, 246, 123, 0, 2687, 2688, 5, 483, 0, 0, 2688, 2690, 3, 246, 123, 0, 2689, 2687, 1, 0, 0, 0, 2690, 2693, 1, 0, 0, 0, 2691, 2689, 1, 0, 0, 0, 2691, 2692, 1, 0, 0, 0, 2692, 245, 1, 0, 0, 0, 2693, 2691, 1, 0, 0, 0, 2694, 2697, 5, 502, 0, 0, 2695, 2697, 3, 176, 88, 0, 2696, 2694, 1, 0, 0, 0, 2696, 2695, 1, 0, 0, 0, 2697, 2698, 1, 0, 0, 0, 2698, 2699, 5, 472, 0, 0, 2699, 2700, 3, 646, 323, 0, 2700, 247, 1, 0, 0, 0, 2701, 2702, 5, 64, 0, 0, 2702, 2703, 5, 33, 0, 0, 2703, 2709, 3, 684, 342, 0, 2704, 2706, 5, 485, 0, 0, 2705, 2707, 3, 250, 125, 0, 2706, 2705, 1, 0, 0, 0, 2706, 2707, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 2710, 5, 486, 0, 0, 2709, 2704, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, 0, 2710, 2713, 1, 0, 0, 0, 2711, 2712, 5, 414, 0, 0, 2712, 2714, 5, 502, 0, 0, 2713, 2711, 1, 0, 0, 0, 2713, 2714, 1, 0, 0, 0, 2714, 2717, 1, 0, 0, 0, 2715, 2716, 5, 137, 0, 0, 2716, 2718, 3, 300, 150, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 249, 1, 0, 0, 0, 2719, 2724, 3, 252, 126, 0, 2720, 2721, 5, 483, 0, 0, 2721, 2723, 3, 252, 126, 0, 2722, 2720, 1, 0, 0, 0, 2723, 2726, 1, 0, 0, 0, 2724, 2722, 1, 0, 0, 0, 2724, 2725, 1, 0, 0, 0, 2725, 251, 1, 0, 0, 0, 2726, 2724, 1, 0, 0, 0, 2727, 2728, 5, 502, 0, 0, 2728, 2731, 5, 472, 0, 0, 2729, 2732, 5, 502, 0, 0, 2730, 2732, 3, 646, 323, 0, 2731, 2729, 1, 0, 0, 0, 2731, 2730, 1, 0, 0, 0, 2732, 2738, 1, 0, 0, 0, 2733, 2734, 3, 686, 343, 0, 2734, 2735, 5, 491, 0, 0, 2735, 2736, 3, 646, 323, 0, 2736, 2738, 1, 0, 0, 0, 2737, 2727, 1, 0, 0, 0, 2737, 2733, 1, 0, 0, 0, 2738, 253, 1, 0, 0, 0, 2739, 2740, 5, 116, 0, 0, 2740, 2741, 5, 33, 0, 0, 2741, 255, 1, 0, 0, 0, 2742, 2743, 5, 64, 0, 0, 2743, 2744, 5, 365, 0, 0, 2744, 2745, 5, 33, 0, 0, 2745, 257, 1, 0, 0, 0, 2746, 2747, 5, 64, 0, 0, 2747, 2748, 5, 393, 0, 0, 2748, 2751, 3, 646, 323, 0, 2749, 2750, 5, 405, 0, 0, 2750, 2752, 3, 686, 343, 0, 2751, 2749, 1, 0, 0, 0, 2751, 2752, 1, 0, 0, 0, 2752, 2758, 1, 0, 0, 0, 2753, 2754, 5, 140, 0, 0, 2754, 2755, 5, 489, 0, 0, 2755, 2756, 3, 682, 341, 0, 2756, 2757, 5, 490, 0, 0, 2757, 2759, 1, 0, 0, 0, 2758, 2753, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, 259, 1, 0, 0, 0, 2760, 2761, 5, 110, 0, 0, 2761, 2762, 3, 646, 323, 0, 2762, 261, 1, 0, 0, 0, 2763, 2764, 5, 293, 0, 0, 2764, 2765, 5, 294, 0, 0, 2765, 2766, 3, 196, 98, 0, 2766, 2767, 5, 393, 0, 0, 2767, 2773, 3, 646, 323, 0, 2768, 2769, 5, 140, 0, 0, 2769, 2770, 5, 489, 0, 0, 2770, 2771, 3, 682, 341, 0, 2771, 2772, 5, 490, 0, 0, 2772, 2774, 1, 0, 0, 0, 2773, 2768, 1, 0, 0, 0, 2773, 2774, 1, 0, 0, 0, 2774, 263, 1, 0, 0, 0, 2775, 2776, 5, 502, 0, 0, 2776, 2778, 5, 472, 0, 0, 2777, 2775, 1, 0, 0, 0, 2777, 2778, 1, 0, 0, 0, 2778, 2779, 1, 0, 0, 0, 2779, 2780, 5, 306, 0, 0, 2780, 2781, 5, 112, 0, 0, 2781, 2782, 3, 266, 133, 0, 2782, 2784, 3, 268, 134, 0, 2783, 2785, 3, 270, 135, 0, 2784, 2783, 1, 0, 0, 0, 2784, 2785, 1, 0, 0, 0, 2785, 2789, 1, 0, 0, 0, 2786, 2788, 3, 272, 136, 0, 2787, 2786, 1, 0, 0, 0, 2788, 2791, 1, 0, 0, 0, 2789, 2787, 1, 0, 0, 0, 2789, 2790, 1, 0, 0, 0, 2790, 2793, 1, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2792, 2794, 3, 274, 137, 0, 2793, 2792, 1, 0, 0, 0, 2793, 2794, 1, 0, 0, 0, 2794, 2796, 1, 0, 0, 0, 2795, 2797, 3, 276, 138, 0, 2796, 2795, 1, 0, 0, 0, 2796, 2797, 1, 0, 0, 0, 2797, 2799, 1, 0, 0, 0, 2798, 2800, 3, 278, 139, 0, 2799, 2798, 1, 0, 0, 0, 2799, 2800, 1, 0, 0, 0, 2800, 2801, 1, 0, 0, 0, 2801, 2803, 3, 280, 140, 0, 2802, 2804, 3, 208, 104, 0, 2803, 2802, 1, 0, 0, 0, 2803, 2804, 1, 0, 0, 0, 2804, 265, 1, 0, 0, 0, 2805, 2806, 7, 13, 0, 0, 2806, 267, 1, 0, 0, 0, 2807, 2810, 5, 499, 0, 0, 2808, 2810, 3, 646, 323, 0, 2809, 2807, 1, 0, 0, 0, 2809, 2808, 1, 0, 0, 0, 2810, 269, 1, 0, 0, 0, 2811, 2812, 3, 228, 114, 0, 2812, 271, 1, 0, 0, 0, 2813, 2814, 5, 193, 0, 0, 2814, 2815, 7, 14, 0, 0, 2815, 2816, 5, 472, 0, 0, 2816, 2817, 3, 646, 323, 0, 2817, 273, 1, 0, 0, 0, 2818, 2819, 5, 311, 0, 0, 2819, 2820, 5, 313, 0, 0, 2820, 2821, 3, 646, 323, 0, 2821, 2822, 5, 342, 0, 0, 2822, 2823, 3, 646, 323, 0, 2823, 275, 1, 0, 0, 0, 2824, 2825, 5, 320, 0, 0, 2825, 2827, 5, 499, 0, 0, 2826, 2828, 3, 228, 114, 0, 2827, 2826, 1, 0, 0, 0, 2827, 2828, 1, 0, 0, 0, 2828, 2841, 1, 0, 0, 0, 2829, 2830, 5, 320, 0, 0, 2830, 2832, 3, 646, 323, 0, 2831, 2833, 3, 228, 114, 0, 2832, 2831, 1, 0, 0, 0, 2832, 2833, 1, 0, 0, 0, 2833, 2841, 1, 0, 0, 0, 2834, 2835, 5, 320, 0, 0, 2835, 2836, 5, 347, 0, 0, 2836, 2837, 3, 684, 342, 0, 2837, 2838, 5, 70, 0, 0, 2838, 2839, 5, 502, 0, 0, 2839, 2841, 1, 0, 0, 0, 2840, 2824, 1, 0, 0, 0, 2840, 2829, 1, 0, 0, 0, 2840, 2834, 1, 0, 0, 0, 2841, 277, 1, 0, 0, 0, 2842, 2843, 5, 319, 0, 0, 2843, 2844, 3, 646, 323, 0, 2844, 279, 1, 0, 0, 0, 2845, 2846, 5, 76, 0, 0, 2846, 2860, 5, 257, 0, 0, 2847, 2848, 5, 76, 0, 0, 2848, 2860, 5, 321, 0, 0, 2849, 2850, 5, 76, 0, 0, 2850, 2851, 5, 347, 0, 0, 2851, 2852, 3, 684, 342, 0, 2852, 2853, 5, 75, 0, 0, 2853, 2854, 3, 684, 342, 0, 2854, 2860, 1, 0, 0, 0, 2855, 2856, 5, 76, 0, 0, 2856, 2860, 5, 409, 0, 0, 2857, 2858, 5, 76, 0, 0, 2858, 2860, 5, 314, 0, 0, 2859, 2845, 1, 0, 0, 0, 2859, 2847, 1, 0, 0, 0, 2859, 2849, 1, 0, 0, 0, 2859, 2855, 1, 0, 0, 0, 2859, 2857, 1, 0, 0, 0, 2860, 281, 1, 0, 0, 0, 2861, 2862, 5, 502, 0, 0, 2862, 2863, 5, 472, 0, 0, 2863, 2864, 3, 284, 142, 0, 2864, 283, 1, 0, 0, 0, 2865, 2866, 5, 119, 0, 0, 2866, 2867, 5, 485, 0, 0, 2867, 2868, 5, 502, 0, 0, 2868, 2925, 5, 486, 0, 0, 2869, 2870, 5, 120, 0, 0, 2870, 2871, 5, 485, 0, 0, 2871, 2872, 5, 502, 0, 0, 2872, 2925, 5, 486, 0, 0, 2873, 2874, 5, 121, 0, 0, 2874, 2875, 5, 485, 0, 0, 2875, 2876, 5, 502, 0, 0, 2876, 2877, 5, 483, 0, 0, 2877, 2878, 3, 646, 323, 0, 2878, 2879, 5, 486, 0, 0, 2879, 2925, 1, 0, 0, 0, 2880, 2881, 5, 183, 0, 0, 2881, 2882, 5, 485, 0, 0, 2882, 2883, 5, 502, 0, 0, 2883, 2884, 5, 483, 0, 0, 2884, 2885, 3, 646, 323, 0, 2885, 2886, 5, 486, 0, 0, 2886, 2925, 1, 0, 0, 0, 2887, 2888, 5, 122, 0, 0, 2888, 2889, 5, 485, 0, 0, 2889, 2890, 5, 502, 0, 0, 2890, 2891, 5, 483, 0, 0, 2891, 2892, 3, 286, 143, 0, 2892, 2893, 5, 486, 0, 0, 2893, 2925, 1, 0, 0, 0, 2894, 2895, 5, 123, 0, 0, 2895, 2896, 5, 485, 0, 0, 2896, 2897, 5, 502, 0, 0, 2897, 2898, 5, 483, 0, 0, 2898, 2899, 5, 502, 0, 0, 2899, 2925, 5, 486, 0, 0, 2900, 2901, 5, 124, 0, 0, 2901, 2902, 5, 485, 0, 0, 2902, 2903, 5, 502, 0, 0, 2903, 2904, 5, 483, 0, 0, 2904, 2905, 5, 502, 0, 0, 2905, 2925, 5, 486, 0, 0, 2906, 2907, 5, 125, 0, 0, 2907, 2908, 5, 485, 0, 0, 2908, 2909, 5, 502, 0, 0, 2909, 2910, 5, 483, 0, 0, 2910, 2911, 5, 502, 0, 0, 2911, 2925, 5, 486, 0, 0, 2912, 2913, 5, 126, 0, 0, 2913, 2914, 5, 485, 0, 0, 2914, 2915, 5, 502, 0, 0, 2915, 2916, 5, 483, 0, 0, 2916, 2917, 5, 502, 0, 0, 2917, 2925, 5, 486, 0, 0, 2918, 2919, 5, 132, 0, 0, 2919, 2920, 5, 485, 0, 0, 2920, 2921, 5, 502, 0, 0, 2921, 2922, 5, 483, 0, 0, 2922, 2923, 5, 502, 0, 0, 2923, 2925, 5, 486, 0, 0, 2924, 2865, 1, 0, 0, 0, 2924, 2869, 1, 0, 0, 0, 2924, 2873, 1, 0, 0, 0, 2924, 2880, 1, 0, 0, 0, 2924, 2887, 1, 0, 0, 0, 2924, 2894, 1, 0, 0, 0, 2924, 2900, 1, 0, 0, 0, 2924, 2906, 1, 0, 0, 0, 2924, 2912, 1, 0, 0, 0, 2924, 2918, 1, 0, 0, 0, 2925, 285, 1, 0, 0, 0, 2926, 2931, 3, 288, 144, 0, 2927, 2928, 5, 483, 0, 0, 2928, 2930, 3, 288, 144, 0, 2929, 2927, 1, 0, 0, 0, 2930, 2933, 1, 0, 0, 0, 2931, 2929, 1, 0, 0, 0, 2931, 2932, 1, 0, 0, 0, 2932, 287, 1, 0, 0, 0, 2933, 2931, 1, 0, 0, 0, 2934, 2936, 5, 503, 0, 0, 2935, 2937, 7, 6, 0, 0, 2936, 2935, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 289, 1, 0, 0, 0, 2938, 2939, 5, 502, 0, 0, 2939, 2940, 5, 472, 0, 0, 2940, 2941, 3, 292, 146, 0, 2941, 291, 1, 0, 0, 0, 2942, 2943, 5, 271, 0, 0, 2943, 2944, 5, 485, 0, 0, 2944, 2945, 5, 502, 0, 0, 2945, 2967, 5, 486, 0, 0, 2946, 2947, 5, 272, 0, 0, 2947, 2948, 5, 485, 0, 0, 2948, 2949, 3, 196, 98, 0, 2949, 2950, 5, 486, 0, 0, 2950, 2967, 1, 0, 0, 0, 2951, 2952, 5, 127, 0, 0, 2952, 2953, 5, 485, 0, 0, 2953, 2954, 3, 196, 98, 0, 2954, 2955, 5, 486, 0, 0, 2955, 2967, 1, 0, 0, 0, 2956, 2957, 5, 128, 0, 0, 2957, 2958, 5, 485, 0, 0, 2958, 2959, 3, 196, 98, 0, 2959, 2960, 5, 486, 0, 0, 2960, 2967, 1, 0, 0, 0, 2961, 2962, 5, 129, 0, 0, 2962, 2963, 5, 485, 0, 0, 2963, 2964, 3, 196, 98, 0, 2964, 2965, 5, 486, 0, 0, 2965, 2967, 1, 0, 0, 0, 2966, 2942, 1, 0, 0, 0, 2966, 2946, 1, 0, 0, 0, 2966, 2951, 1, 0, 0, 0, 2966, 2956, 1, 0, 0, 0, 2966, 2961, 1, 0, 0, 0, 2967, 293, 1, 0, 0, 0, 2968, 2969, 5, 502, 0, 0, 2969, 2970, 5, 472, 0, 0, 2970, 2971, 5, 17, 0, 0, 2971, 2972, 5, 13, 0, 0, 2972, 2973, 3, 684, 342, 0, 2973, 295, 1, 0, 0, 0, 2974, 2975, 5, 46, 0, 0, 2975, 2976, 5, 502, 0, 0, 2976, 2977, 5, 411, 0, 0, 2977, 2978, 5, 502, 0, 0, 2978, 297, 1, 0, 0, 0, 2979, 2980, 5, 131, 0, 0, 2980, 2981, 5, 502, 0, 0, 2981, 2982, 5, 70, 0, 0, 2982, 2983, 5, 502, 0, 0, 2983, 299, 1, 0, 0, 0, 2984, 2989, 3, 302, 151, 0, 2985, 2986, 5, 483, 0, 0, 2986, 2988, 3, 302, 151, 0, 2987, 2985, 1, 0, 0, 0, 2988, 2991, 1, 0, 0, 0, 2989, 2987, 1, 0, 0, 0, 2989, 2990, 1, 0, 0, 0, 2990, 301, 1, 0, 0, 0, 2991, 2989, 1, 0, 0, 0, 2992, 2993, 3, 304, 152, 0, 2993, 2994, 5, 472, 0, 0, 2994, 2995, 3, 646, 323, 0, 2995, 303, 1, 0, 0, 0, 2996, 3001, 3, 684, 342, 0, 2997, 3001, 5, 503, 0, 0, 2998, 3001, 5, 505, 0, 0, 2999, 3001, 3, 706, 353, 0, 3000, 2996, 1, 0, 0, 0, 3000, 2997, 1, 0, 0, 0, 3000, 2998, 1, 0, 0, 0, 3000, 2999, 1, 0, 0, 0, 3001, 305, 1, 0, 0, 0, 3002, 3007, 3, 308, 154, 0, 3003, 3004, 5, 483, 0, 0, 3004, 3006, 3, 308, 154, 0, 3005, 3003, 1, 0, 0, 0, 3006, 3009, 1, 0, 0, 0, 3007, 3005, 1, 0, 0, 0, 3007, 3008, 1, 0, 0, 0, 3008, 307, 1, 0, 0, 0, 3009, 3007, 1, 0, 0, 0, 3010, 3011, 5, 503, 0, 0, 3011, 3012, 5, 472, 0, 0, 3012, 3013, 3, 646, 323, 0, 3013, 309, 1, 0, 0, 0, 3014, 3015, 5, 33, 0, 0, 3015, 3016, 3, 684, 342, 0, 3016, 3017, 3, 360, 180, 0, 3017, 3018, 5, 487, 0, 0, 3018, 3019, 3, 368, 184, 0, 3019, 3020, 5, 488, 0, 0, 3020, 311, 1, 0, 0, 0, 3021, 3022, 5, 34, 0, 0, 3022, 3024, 3, 684, 342, 0, 3023, 3025, 3, 364, 182, 0, 3024, 3023, 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 3027, 1, 0, 0, 0, 3026, 3028, 3, 314, 157, 0, 3027, 3026, 1, 0, 0, 0, 3027, 3028, 1, 0, 0, 0, 3028, 3029, 1, 0, 0, 0, 3029, 3030, 5, 487, 0, 0, 3030, 3031, 3, 368, 184, 0, 3031, 3032, 5, 488, 0, 0, 3032, 313, 1, 0, 0, 0, 3033, 3035, 3, 316, 158, 0, 3034, 3033, 1, 0, 0, 0, 3035, 3036, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 315, 1, 0, 0, 0, 3038, 3039, 5, 215, 0, 0, 3039, 3040, 5, 499, 0, 0, 3040, 317, 1, 0, 0, 0, 3041, 3046, 3, 320, 160, 0, 3042, 3043, 5, 483, 0, 0, 3043, 3045, 3, 320, 160, 0, 3044, 3042, 1, 0, 0, 0, 3045, 3048, 1, 0, 0, 0, 3046, 3044, 1, 0, 0, 0, 3046, 3047, 1, 0, 0, 0, 3047, 319, 1, 0, 0, 0, 3048, 3046, 1, 0, 0, 0, 3049, 3050, 7, 15, 0, 0, 3050, 3051, 5, 491, 0, 0, 3051, 3052, 3, 102, 51, 0, 3052, 321, 1, 0, 0, 0, 3053, 3058, 3, 324, 162, 0, 3054, 3055, 5, 483, 0, 0, 3055, 3057, 3, 324, 162, 0, 3056, 3054, 1, 0, 0, 0, 3057, 3060, 1, 0, 0, 0, 3058, 3056, 1, 0, 0, 0, 3058, 3059, 1, 0, 0, 0, 3059, 323, 1, 0, 0, 0, 3060, 3058, 1, 0, 0, 0, 3061, 3062, 7, 15, 0, 0, 3062, 3063, 5, 491, 0, 0, 3063, 3064, 3, 102, 51, 0, 3064, 325, 1, 0, 0, 0, 3065, 3070, 3, 328, 164, 0, 3066, 3067, 5, 483, 0, 0, 3067, 3069, 3, 328, 164, 0, 3068, 3066, 1, 0, 0, 0, 3069, 3072, 1, 0, 0, 0, 3070, 3068, 1, 0, 0, 0, 3070, 3071, 1, 0, 0, 0, 3071, 327, 1, 0, 0, 0, 3072, 3070, 1, 0, 0, 0, 3073, 3074, 5, 502, 0, 0, 3074, 3075, 5, 491, 0, 0, 3075, 3076, 3, 102, 51, 0, 3076, 3077, 5, 472, 0, 0, 3077, 3078, 5, 499, 0, 0, 3078, 329, 1, 0, 0, 0, 3079, 3082, 3, 684, 342, 0, 3080, 3082, 5, 503, 0, 0, 3081, 3079, 1, 0, 0, 0, 3081, 3080, 1, 0, 0, 0, 3082, 3084, 1, 0, 0, 0, 3083, 3085, 7, 6, 0, 0, 3084, 3083, 1, 0, 0, 0, 3084, 3085, 1, 0, 0, 0, 3085, 331, 1, 0, 0, 0, 3086, 3087, 5, 489, 0, 0, 3087, 3088, 3, 336, 168, 0, 3088, 3089, 5, 490, 0, 0, 3089, 333, 1, 0, 0, 0, 3090, 3091, 7, 16, 0, 0, 3091, 335, 1, 0, 0, 0, 3092, 3097, 3, 338, 169, 0, 3093, 3094, 5, 281, 0, 0, 3094, 3096, 3, 338, 169, 0, 3095, 3093, 1, 0, 0, 0, 3096, 3099, 1, 0, 0, 0, 3097, 3095, 1, 0, 0, 0, 3097, 3098, 1, 0, 0, 0, 3098, 337, 1, 0, 0, 0, 3099, 3097, 1, 0, 0, 0, 3100, 3105, 3, 340, 170, 0, 3101, 3102, 5, 280, 0, 0, 3102, 3104, 3, 340, 170, 0, 3103, 3101, 1, 0, 0, 0, 3104, 3107, 1, 0, 0, 0, 3105, 3103, 1, 0, 0, 0, 3105, 3106, 1, 0, 0, 0, 3106, 339, 1, 0, 0, 0, 3107, 3105, 1, 0, 0, 0, 3108, 3109, 5, 282, 0, 0, 3109, 3112, 3, 340, 170, 0, 3110, 3112, 3, 342, 171, 0, 3111, 3108, 1, 0, 0, 0, 3111, 3110, 1, 0, 0, 0, 3112, 341, 1, 0, 0, 0, 3113, 3117, 3, 344, 172, 0, 3114, 3115, 3, 656, 328, 0, 3115, 3116, 3, 344, 172, 0, 3116, 3118, 1, 0, 0, 0, 3117, 3114, 1, 0, 0, 0, 3117, 3118, 1, 0, 0, 0, 3118, 343, 1, 0, 0, 0, 3119, 3126, 3, 356, 178, 0, 3120, 3126, 3, 346, 173, 0, 3121, 3122, 5, 485, 0, 0, 3122, 3123, 3, 336, 168, 0, 3123, 3124, 5, 486, 0, 0, 3124, 3126, 1, 0, 0, 0, 3125, 3119, 1, 0, 0, 0, 3125, 3120, 1, 0, 0, 0, 3125, 3121, 1, 0, 0, 0, 3126, 345, 1, 0, 0, 0, 3127, 3132, 3, 348, 174, 0, 3128, 3129, 5, 478, 0, 0, 3129, 3131, 3, 348, 174, 0, 3130, 3128, 1, 0, 0, 0, 3131, 3134, 1, 0, 0, 0, 3132, 3130, 1, 0, 0, 0, 3132, 3133, 1, 0, 0, 0, 3133, 347, 1, 0, 0, 0, 3134, 3132, 1, 0, 0, 0, 3135, 3140, 3, 350, 175, 0, 3136, 3137, 5, 489, 0, 0, 3137, 3138, 3, 336, 168, 0, 3138, 3139, 5, 490, 0, 0, 3139, 3141, 1, 0, 0, 0, 3140, 3136, 1, 0, 0, 0, 3140, 3141, 1, 0, 0, 0, 3141, 349, 1, 0, 0, 0, 3142, 3148, 3, 352, 176, 0, 3143, 3148, 5, 502, 0, 0, 3144, 3148, 5, 499, 0, 0, 3145, 3148, 5, 501, 0, 0, 3146, 3148, 5, 498, 0, 0, 3147, 3142, 1, 0, 0, 0, 3147, 3143, 1, 0, 0, 0, 3147, 3144, 1, 0, 0, 0, 3147, 3145, 1, 0, 0, 0, 3147, 3146, 1, 0, 0, 0, 3148, 351, 1, 0, 0, 0, 3149, 3154, 3, 354, 177, 0, 3150, 3151, 5, 484, 0, 0, 3151, 3153, 3, 354, 177, 0, 3152, 3150, 1, 0, 0, 0, 3153, 3156, 1, 0, 0, 0, 3154, 3152, 1, 0, 0, 0, 3154, 3155, 1, 0, 0, 0, 3155, 353, 1, 0, 0, 0, 3156, 3154, 1, 0, 0, 0, 3157, 3158, 8, 17, 0, 0, 3158, 355, 1, 0, 0, 0, 3159, 3160, 3, 358, 179, 0, 3160, 3169, 5, 485, 0, 0, 3161, 3166, 3, 336, 168, 0, 3162, 3163, 5, 483, 0, 0, 3163, 3165, 3, 336, 168, 0, 3164, 3162, 1, 0, 0, 0, 3165, 3168, 1, 0, 0, 0, 3166, 3164, 1, 0, 0, 0, 3166, 3167, 1, 0, 0, 0, 3167, 3170, 1, 0, 0, 0, 3168, 3166, 1, 0, 0, 0, 3169, 3161, 1, 0, 0, 0, 3169, 3170, 1, 0, 0, 0, 3170, 3171, 1, 0, 0, 0, 3171, 3172, 5, 486, 0, 0, 3172, 357, 1, 0, 0, 0, 3173, 3174, 7, 18, 0, 0, 3174, 359, 1, 0, 0, 0, 3175, 3176, 5, 485, 0, 0, 3176, 3181, 3, 362, 181, 0, 3177, 3178, 5, 483, 0, 0, 3178, 3180, 3, 362, 181, 0, 3179, 3177, 1, 0, 0, 0, 3180, 3183, 1, 0, 0, 0, 3181, 3179, 1, 0, 0, 0, 3181, 3182, 1, 0, 0, 0, 3182, 3184, 1, 0, 0, 0, 3183, 3181, 1, 0, 0, 0, 3184, 3185, 5, 486, 0, 0, 3185, 361, 1, 0, 0, 0, 3186, 3187, 5, 200, 0, 0, 3187, 3188, 5, 491, 0, 0, 3188, 3189, 5, 487, 0, 0, 3189, 3190, 3, 318, 159, 0, 3190, 3191, 5, 488, 0, 0, 3191, 3214, 1, 0, 0, 0, 3192, 3193, 5, 201, 0, 0, 3193, 3194, 5, 491, 0, 0, 3194, 3195, 5, 487, 0, 0, 3195, 3196, 3, 326, 163, 0, 3196, 3197, 5, 488, 0, 0, 3197, 3214, 1, 0, 0, 0, 3198, 3199, 5, 162, 0, 0, 3199, 3200, 5, 491, 0, 0, 3200, 3214, 5, 499, 0, 0, 3201, 3202, 5, 35, 0, 0, 3202, 3205, 5, 491, 0, 0, 3203, 3206, 3, 684, 342, 0, 3204, 3206, 5, 499, 0, 0, 3205, 3203, 1, 0, 0, 0, 3205, 3204, 1, 0, 0, 0, 3206, 3214, 1, 0, 0, 0, 3207, 3208, 5, 214, 0, 0, 3208, 3209, 5, 491, 0, 0, 3209, 3214, 5, 499, 0, 0, 3210, 3211, 5, 215, 0, 0, 3211, 3212, 5, 491, 0, 0, 3212, 3214, 5, 499, 0, 0, 3213, 3186, 1, 0, 0, 0, 3213, 3192, 1, 0, 0, 0, 3213, 3198, 1, 0, 0, 0, 3213, 3201, 1, 0, 0, 0, 3213, 3207, 1, 0, 0, 0, 3213, 3210, 1, 0, 0, 0, 3214, 363, 1, 0, 0, 0, 3215, 3216, 5, 485, 0, 0, 3216, 3221, 3, 366, 183, 0, 3217, 3218, 5, 483, 0, 0, 3218, 3220, 3, 366, 183, 0, 3219, 3217, 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, 3225, 5, 486, 0, 0, 3225, 365, 1, 0, 0, 0, 3226, 3227, 5, 200, 0, 0, 3227, 3228, 5, 491, 0, 0, 3228, 3229, 5, 487, 0, 0, 3229, 3230, 3, 322, 161, 0, 3230, 3231, 5, 488, 0, 0, 3231, 3242, 1, 0, 0, 0, 3232, 3233, 5, 201, 0, 0, 3233, 3234, 5, 491, 0, 0, 3234, 3235, 5, 487, 0, 0, 3235, 3236, 3, 326, 163, 0, 3236, 3237, 5, 488, 0, 0, 3237, 3242, 1, 0, 0, 0, 3238, 3239, 5, 215, 0, 0, 3239, 3240, 5, 491, 0, 0, 3240, 3242, 5, 499, 0, 0, 3241, 3226, 1, 0, 0, 0, 3241, 3232, 1, 0, 0, 0, 3241, 3238, 1, 0, 0, 0, 3242, 367, 1, 0, 0, 0, 3243, 3246, 3, 372, 186, 0, 3244, 3246, 3, 370, 185, 0, 3245, 3243, 1, 0, 0, 0, 3245, 3244, 1, 0, 0, 0, 3246, 3249, 1, 0, 0, 0, 3247, 3245, 1, 0, 0, 0, 3247, 3248, 1, 0, 0, 0, 3248, 369, 1, 0, 0, 0, 3249, 3247, 1, 0, 0, 0, 3250, 3251, 5, 66, 0, 0, 3251, 3252, 5, 378, 0, 0, 3252, 3255, 3, 686, 343, 0, 3253, 3254, 5, 75, 0, 0, 3254, 3256, 3, 686, 343, 0, 3255, 3253, 1, 0, 0, 0, 3255, 3256, 1, 0, 0, 0, 3256, 371, 1, 0, 0, 0, 3257, 3258, 3, 374, 187, 0, 3258, 3260, 5, 503, 0, 0, 3259, 3261, 3, 376, 188, 0, 3260, 3259, 1, 0, 0, 0, 3260, 3261, 1, 0, 0, 0, 3261, 3263, 1, 0, 0, 0, 3262, 3264, 3, 414, 207, 0, 3263, 3262, 1, 0, 0, 0, 3263, 3264, 1, 0, 0, 0, 3264, 373, 1, 0, 0, 0, 3265, 3266, 7, 19, 0, 0, 3266, 375, 1, 0, 0, 0, 3267, 3268, 5, 485, 0, 0, 3268, 3273, 3, 378, 189, 0, 3269, 3270, 5, 483, 0, 0, 3270, 3272, 3, 378, 189, 0, 3271, 3269, 1, 0, 0, 0, 3272, 3275, 1, 0, 0, 0, 3273, 3271, 1, 0, 0, 0, 3273, 3274, 1, 0, 0, 0, 3274, 3276, 1, 0, 0, 0, 3275, 3273, 1, 0, 0, 0, 3276, 3277, 5, 486, 0, 0, 3277, 377, 1, 0, 0, 0, 3278, 3279, 5, 189, 0, 0, 3279, 3280, 5, 491, 0, 0, 3280, 3354, 3, 384, 192, 0, 3281, 3282, 5, 38, 0, 0, 3282, 3283, 5, 491, 0, 0, 3283, 3354, 3, 392, 196, 0, 3284, 3285, 5, 196, 0, 0, 3285, 3286, 5, 491, 0, 0, 3286, 3354, 3, 392, 196, 0, 3287, 3288, 5, 114, 0, 0, 3288, 3289, 5, 491, 0, 0, 3289, 3354, 3, 386, 193, 0, 3290, 3291, 5, 186, 0, 0, 3291, 3292, 5, 491, 0, 0, 3292, 3354, 3, 394, 197, 0, 3293, 3294, 5, 166, 0, 0, 3294, 3295, 5, 491, 0, 0, 3295, 3354, 5, 499, 0, 0, 3296, 3297, 5, 197, 0, 0, 3297, 3298, 5, 491, 0, 0, 3298, 3354, 3, 392, 196, 0, 3299, 3300, 5, 194, 0, 0, 3300, 3301, 5, 491, 0, 0, 3301, 3354, 3, 394, 197, 0, 3302, 3303, 5, 195, 0, 0, 3303, 3304, 5, 491, 0, 0, 3304, 3354, 3, 400, 200, 0, 3305, 3306, 5, 198, 0, 0, 3306, 3307, 5, 491, 0, 0, 3307, 3354, 3, 396, 198, 0, 3308, 3309, 5, 199, 0, 0, 3309, 3310, 5, 491, 0, 0, 3310, 3354, 3, 396, 198, 0, 3311, 3312, 5, 205, 0, 0, 3312, 3313, 5, 491, 0, 0, 3313, 3354, 3, 402, 201, 0, 3314, 3315, 5, 203, 0, 0, 3315, 3316, 5, 491, 0, 0, 3316, 3354, 5, 499, 0, 0, 3317, 3318, 5, 204, 0, 0, 3318, 3319, 5, 491, 0, 0, 3319, 3354, 5, 499, 0, 0, 3320, 3321, 5, 202, 0, 0, 3321, 3322, 5, 491, 0, 0, 3322, 3354, 3, 404, 202, 0, 3323, 3324, 5, 191, 0, 0, 3324, 3325, 5, 491, 0, 0, 3325, 3354, 3, 406, 203, 0, 3326, 3327, 5, 34, 0, 0, 3327, 3328, 5, 491, 0, 0, 3328, 3354, 3, 684, 342, 0, 3329, 3330, 5, 220, 0, 0, 3330, 3331, 5, 491, 0, 0, 3331, 3354, 3, 382, 191, 0, 3332, 3333, 5, 221, 0, 0, 3333, 3334, 5, 491, 0, 0, 3334, 3354, 3, 380, 190, 0, 3335, 3336, 5, 208, 0, 0, 3336, 3337, 5, 491, 0, 0, 3337, 3354, 3, 410, 205, 0, 3338, 3339, 5, 211, 0, 0, 3339, 3340, 5, 491, 0, 0, 3340, 3354, 5, 501, 0, 0, 3341, 3342, 5, 212, 0, 0, 3342, 3343, 5, 491, 0, 0, 3343, 3354, 5, 501, 0, 0, 3344, 3345, 5, 227, 0, 0, 3345, 3346, 5, 491, 0, 0, 3346, 3354, 3, 408, 204, 0, 3347, 3348, 5, 188, 0, 0, 3348, 3349, 5, 491, 0, 0, 3349, 3354, 3, 408, 204, 0, 3350, 3351, 5, 503, 0, 0, 3351, 3352, 5, 491, 0, 0, 3352, 3354, 3, 408, 204, 0, 3353, 3278, 1, 0, 0, 0, 3353, 3281, 1, 0, 0, 0, 3353, 3284, 1, 0, 0, 0, 3353, 3287, 1, 0, 0, 0, 3353, 3290, 1, 0, 0, 0, 3353, 3293, 1, 0, 0, 0, 3353, 3296, 1, 0, 0, 0, 3353, 3299, 1, 0, 0, 0, 3353, 3302, 1, 0, 0, 0, 3353, 3305, 1, 0, 0, 0, 3353, 3308, 1, 0, 0, 0, 3353, 3311, 1, 0, 0, 0, 3353, 3314, 1, 0, 0, 0, 3353, 3317, 1, 0, 0, 0, 3353, 3320, 1, 0, 0, 0, 3353, 3323, 1, 0, 0, 0, 3353, 3326, 1, 0, 0, 0, 3353, 3329, 1, 0, 0, 0, 3353, 3332, 1, 0, 0, 0, 3353, 3335, 1, 0, 0, 0, 3353, 3338, 1, 0, 0, 0, 3353, 3341, 1, 0, 0, 0, 3353, 3344, 1, 0, 0, 0, 3353, 3347, 1, 0, 0, 0, 3353, 3350, 1, 0, 0, 0, 3354, 379, 1, 0, 0, 0, 3355, 3356, 7, 20, 0, 0, 3356, 381, 1, 0, 0, 0, 3357, 3358, 5, 489, 0, 0, 3358, 3363, 3, 684, 342, 0, 3359, 3360, 5, 483, 0, 0, 3360, 3362, 3, 684, 342, 0, 3361, 3359, 1, 0, 0, 0, 3362, 3365, 1, 0, 0, 0, 3363, 3361, 1, 0, 0, 0, 3363, 3364, 1, 0, 0, 0, 3364, 3366, 1, 0, 0, 0, 3365, 3363, 1, 0, 0, 0, 3366, 3367, 5, 490, 0, 0, 3367, 383, 1, 0, 0, 0, 3368, 3415, 5, 502, 0, 0, 3369, 3371, 5, 344, 0, 0, 3370, 3372, 5, 70, 0, 0, 3371, 3370, 1, 0, 0, 0, 3371, 3372, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, 3387, 3, 684, 342, 0, 3374, 3385, 5, 71, 0, 0, 3375, 3381, 3, 332, 166, 0, 3376, 3377, 3, 334, 167, 0, 3377, 3378, 3, 332, 166, 0, 3378, 3380, 1, 0, 0, 0, 3379, 3376, 1, 0, 0, 0, 3380, 3383, 1, 0, 0, 0, 3381, 3379, 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, 3386, 1, 0, 0, 0, 3383, 3381, 1, 0, 0, 0, 3384, 3386, 3, 646, 323, 0, 3385, 3375, 1, 0, 0, 0, 3385, 3384, 1, 0, 0, 0, 3386, 3388, 1, 0, 0, 0, 3387, 3374, 1, 0, 0, 0, 3387, 3388, 1, 0, 0, 0, 3388, 3398, 1, 0, 0, 0, 3389, 3390, 5, 10, 0, 0, 3390, 3395, 3, 330, 165, 0, 3391, 3392, 5, 483, 0, 0, 3392, 3394, 3, 330, 165, 0, 3393, 3391, 1, 0, 0, 0, 3394, 3397, 1, 0, 0, 0, 3395, 3393, 1, 0, 0, 0, 3395, 3396, 1, 0, 0, 0, 3396, 3399, 1, 0, 0, 0, 3397, 3395, 1, 0, 0, 0, 3398, 3389, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0, 3399, 3415, 1, 0, 0, 0, 3400, 3401, 5, 30, 0, 0, 3401, 3403, 3, 684, 342, 0, 3402, 3404, 3, 388, 194, 0, 3403, 3402, 1, 0, 0, 0, 3403, 3404, 1, 0, 0, 0, 3404, 3415, 1, 0, 0, 0, 3405, 3406, 5, 31, 0, 0, 3406, 3408, 3, 684, 342, 0, 3407, 3409, 3, 388, 194, 0, 3408, 3407, 1, 0, 0, 0, 3408, 3409, 1, 0, 0, 0, 3409, 3415, 1, 0, 0, 0, 3410, 3411, 5, 27, 0, 0, 3411, 3415, 3, 392, 196, 0, 3412, 3413, 5, 191, 0, 0, 3413, 3415, 5, 503, 0, 0, 3414, 3368, 1, 0, 0, 0, 3414, 3369, 1, 0, 0, 0, 3414, 3400, 1, 0, 0, 0, 3414, 3405, 1, 0, 0, 0, 3414, 3410, 1, 0, 0, 0, 3414, 3412, 1, 0, 0, 0, 3415, 385, 1, 0, 0, 0, 3416, 3418, 5, 229, 0, 0, 3417, 3419, 5, 231, 0, 0, 3418, 3417, 1, 0, 0, 0, 3418, 3419, 1, 0, 0, 0, 3419, 3455, 1, 0, 0, 0, 3420, 3422, 5, 230, 0, 0, 3421, 3423, 5, 231, 0, 0, 3422, 3421, 1, 0, 0, 0, 3422, 3423, 1, 0, 0, 0, 3423, 3455, 1, 0, 0, 0, 3424, 3455, 5, 231, 0, 0, 3425, 3455, 5, 234, 0, 0, 3426, 3428, 5, 99, 0, 0, 3427, 3429, 5, 231, 0, 0, 3428, 3427, 1, 0, 0, 0, 3428, 3429, 1, 0, 0, 0, 3429, 3455, 1, 0, 0, 0, 3430, 3431, 5, 235, 0, 0, 3431, 3434, 3, 684, 342, 0, 3432, 3433, 5, 80, 0, 0, 3433, 3435, 3, 386, 193, 0, 3434, 3432, 1, 0, 0, 0, 3434, 3435, 1, 0, 0, 0, 3435, 3455, 1, 0, 0, 0, 3436, 3437, 5, 232, 0, 0, 3437, 3439, 3, 684, 342, 0, 3438, 3440, 3, 388, 194, 0, 3439, 3438, 1, 0, 0, 0, 3439, 3440, 1, 0, 0, 0, 3440, 3455, 1, 0, 0, 0, 3441, 3442, 5, 30, 0, 0, 3442, 3444, 3, 684, 342, 0, 3443, 3445, 3, 388, 194, 0, 3444, 3443, 1, 0, 0, 0, 3444, 3445, 1, 0, 0, 0, 3445, 3455, 1, 0, 0, 0, 3446, 3447, 5, 31, 0, 0, 3447, 3449, 3, 684, 342, 0, 3448, 3450, 3, 388, 194, 0, 3449, 3448, 1, 0, 0, 0, 3449, 3450, 1, 0, 0, 0, 3450, 3455, 1, 0, 0, 0, 3451, 3452, 5, 238, 0, 0, 3452, 3455, 5, 499, 0, 0, 3453, 3455, 5, 239, 0, 0, 3454, 3416, 1, 0, 0, 0, 3454, 3420, 1, 0, 0, 0, 3454, 3424, 1, 0, 0, 0, 3454, 3425, 1, 0, 0, 0, 3454, 3426, 1, 0, 0, 0, 3454, 3430, 1, 0, 0, 0, 3454, 3436, 1, 0, 0, 0, 3454, 3441, 1, 0, 0, 0, 3454, 3446, 1, 0, 0, 0, 3454, 3451, 1, 0, 0, 0, 3454, 3453, 1, 0, 0, 0, 3455, 387, 1, 0, 0, 0, 3456, 3457, 5, 485, 0, 0, 3457, 3462, 3, 390, 195, 0, 3458, 3459, 5, 483, 0, 0, 3459, 3461, 3, 390, 195, 0, 3460, 3458, 1, 0, 0, 0, 3461, 3464, 1, 0, 0, 0, 3462, 3460, 1, 0, 0, 0, 3462, 3463, 1, 0, 0, 0, 3463, 3465, 1, 0, 0, 0, 3464, 3462, 1, 0, 0, 0, 3465, 3466, 5, 486, 0, 0, 3466, 389, 1, 0, 0, 0, 3467, 3468, 5, 503, 0, 0, 3468, 3469, 5, 491, 0, 0, 3469, 3474, 3, 646, 323, 0, 3470, 3471, 5, 502, 0, 0, 3471, 3472, 5, 472, 0, 0, 3472, 3474, 3, 646, 323, 0, 3473, 3467, 1, 0, 0, 0, 3473, 3470, 1, 0, 0, 0, 3474, 391, 1, 0, 0, 0, 3475, 3479, 5, 503, 0, 0, 3476, 3479, 5, 505, 0, 0, 3477, 3479, 3, 708, 354, 0, 3478, 3475, 1, 0, 0, 0, 3478, 3476, 1, 0, 0, 0, 3478, 3477, 1, 0, 0, 0, 3479, 3488, 1, 0, 0, 0, 3480, 3484, 5, 478, 0, 0, 3481, 3485, 5, 503, 0, 0, 3482, 3485, 5, 505, 0, 0, 3483, 3485, 3, 708, 354, 0, 3484, 3481, 1, 0, 0, 0, 3484, 3482, 1, 0, 0, 0, 3484, 3483, 1, 0, 0, 0, 3485, 3487, 1, 0, 0, 0, 3486, 3480, 1, 0, 0, 0, 3487, 3490, 1, 0, 0, 0, 3488, 3486, 1, 0, 0, 0, 3488, 3489, 1, 0, 0, 0, 3489, 393, 1, 0, 0, 0, 3490, 3488, 1, 0, 0, 0, 3491, 3502, 5, 499, 0, 0, 3492, 3502, 3, 392, 196, 0, 3493, 3499, 5, 502, 0, 0, 3494, 3497, 5, 484, 0, 0, 3495, 3498, 5, 503, 0, 0, 3496, 3498, 3, 708, 354, 0, 3497, 3495, 1, 0, 0, 0, 3497, 3496, 1, 0, 0, 0, 3498, 3500, 1, 0, 0, 0, 3499, 3494, 1, 0, 0, 0, 3499, 3500, 1, 0, 0, 0, 3500, 3502, 1, 0, 0, 0, 3501, 3491, 1, 0, 0, 0, 3501, 3492, 1, 0, 0, 0, 3501, 3493, 1, 0, 0, 0, 3502, 395, 1, 0, 0, 0, 3503, 3504, 5, 489, 0, 0, 3504, 3509, 3, 398, 199, 0, 3505, 3506, 5, 483, 0, 0, 3506, 3508, 3, 398, 199, 0, 3507, 3505, 1, 0, 0, 0, 3508, 3511, 1, 0, 0, 0, 3509, 3507, 1, 0, 0, 0, 3509, 3510, 1, 0, 0, 0, 3510, 3512, 1, 0, 0, 0, 3511, 3509, 1, 0, 0, 0, 3512, 3513, 5, 490, 0, 0, 3513, 397, 1, 0, 0, 0, 3514, 3515, 5, 487, 0, 0, 3515, 3516, 5, 501, 0, 0, 3516, 3517, 5, 488, 0, 0, 3517, 3518, 5, 472, 0, 0, 3518, 3519, 3, 646, 323, 0, 3519, 399, 1, 0, 0, 0, 3520, 3521, 7, 21, 0, 0, 3521, 401, 1, 0, 0, 0, 3522, 3523, 7, 22, 0, 0, 3523, 403, 1, 0, 0, 0, 3524, 3525, 7, 23, 0, 0, 3525, 405, 1, 0, 0, 0, 3526, 3527, 7, 24, 0, 0, 3527, 407, 1, 0, 0, 0, 3528, 3552, 5, 499, 0, 0, 3529, 3552, 5, 501, 0, 0, 3530, 3552, 3, 692, 346, 0, 3531, 3552, 3, 684, 342, 0, 3532, 3552, 5, 503, 0, 0, 3533, 3552, 5, 250, 0, 0, 3534, 3552, 5, 251, 0, 0, 3535, 3552, 5, 252, 0, 0, 3536, 3552, 5, 253, 0, 0, 3537, 3552, 5, 254, 0, 0, 3538, 3552, 5, 255, 0, 0, 3539, 3548, 5, 489, 0, 0, 3540, 3545, 3, 646, 323, 0, 3541, 3542, 5, 483, 0, 0, 3542, 3544, 3, 646, 323, 0, 3543, 3541, 1, 0, 0, 0, 3544, 3547, 1, 0, 0, 0, 3545, 3543, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 3549, 1, 0, 0, 0, 3547, 3545, 1, 0, 0, 0, 3548, 3540, 1, 0, 0, 0, 3548, 3549, 1, 0, 0, 0, 3549, 3550, 1, 0, 0, 0, 3550, 3552, 5, 490, 0, 0, 3551, 3528, 1, 0, 0, 0, 3551, 3529, 1, 0, 0, 0, 3551, 3530, 1, 0, 0, 0, 3551, 3531, 1, 0, 0, 0, 3551, 3532, 1, 0, 0, 0, 3551, 3533, 1, 0, 0, 0, 3551, 3534, 1, 0, 0, 0, 3551, 3535, 1, 0, 0, 0, 3551, 3536, 1, 0, 0, 0, 3551, 3537, 1, 0, 0, 0, 3551, 3538, 1, 0, 0, 0, 3551, 3539, 1, 0, 0, 0, 3552, 409, 1, 0, 0, 0, 3553, 3554, 5, 489, 0, 0, 3554, 3559, 3, 412, 206, 0, 3555, 3556, 5, 483, 0, 0, 3556, 3558, 3, 412, 206, 0, 3557, 3555, 1, 0, 0, 0, 3558, 3561, 1, 0, 0, 0, 3559, 3557, 1, 0, 0, 0, 3559, 3560, 1, 0, 0, 0, 3560, 3562, 1, 0, 0, 0, 3561, 3559, 1, 0, 0, 0, 3562, 3563, 5, 490, 0, 0, 3563, 3567, 1, 0, 0, 0, 3564, 3565, 5, 489, 0, 0, 3565, 3567, 5, 490, 0, 0, 3566, 3553, 1, 0, 0, 0, 3566, 3564, 1, 0, 0, 0, 3567, 411, 1, 0, 0, 0, 3568, 3569, 5, 499, 0, 0, 3569, 3570, 5, 491, 0, 0, 3570, 3578, 5, 499, 0, 0, 3571, 3572, 5, 499, 0, 0, 3572, 3573, 5, 491, 0, 0, 3573, 3578, 5, 92, 0, 0, 3574, 3575, 5, 499, 0, 0, 3575, 3576, 5, 491, 0, 0, 3576, 3578, 5, 467, 0, 0, 3577, 3568, 1, 0, 0, 0, 3577, 3571, 1, 0, 0, 0, 3577, 3574, 1, 0, 0, 0, 3578, 413, 1, 0, 0, 0, 3579, 3580, 5, 487, 0, 0, 3580, 3581, 3, 368, 184, 0, 3581, 3582, 5, 488, 0, 0, 3582, 415, 1, 0, 0, 0, 3583, 3584, 5, 36, 0, 0, 3584, 3586, 3, 684, 342, 0, 3585, 3587, 3, 418, 209, 0, 3586, 3585, 1, 0, 0, 0, 3586, 3587, 1, 0, 0, 0, 3587, 3588, 1, 0, 0, 0, 3588, 3592, 5, 95, 0, 0, 3589, 3591, 3, 422, 211, 0, 3590, 3589, 1, 0, 0, 0, 3591, 3594, 1, 0, 0, 0, 3592, 3590, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 3595, 1, 0, 0, 0, 3594, 3592, 1, 0, 0, 0, 3595, 3596, 5, 82, 0, 0, 3596, 417, 1, 0, 0, 0, 3597, 3599, 3, 420, 210, 0, 3598, 3597, 1, 0, 0, 0, 3599, 3600, 1, 0, 0, 0, 3600, 3598, 1, 0, 0, 0, 3600, 3601, 1, 0, 0, 0, 3601, 419, 1, 0, 0, 0, 3602, 3603, 5, 394, 0, 0, 3603, 3604, 5, 499, 0, 0, 3604, 421, 1, 0, 0, 0, 3605, 3606, 5, 33, 0, 0, 3606, 3609, 3, 684, 342, 0, 3607, 3608, 5, 186, 0, 0, 3608, 3610, 5, 499, 0, 0, 3609, 3607, 1, 0, 0, 0, 3609, 3610, 1, 0, 0, 0, 3610, 423, 1, 0, 0, 0, 3611, 3612, 5, 344, 0, 0, 3612, 3613, 5, 343, 0, 0, 3613, 3615, 3, 684, 342, 0, 3614, 3616, 3, 426, 213, 0, 3615, 3614, 1, 0, 0, 0, 3616, 3617, 1, 0, 0, 0, 3617, 3615, 1, 0, 0, 0, 3617, 3618, 1, 0, 0, 0, 3618, 3627, 1, 0, 0, 0, 3619, 3623, 5, 95, 0, 0, 3620, 3622, 3, 428, 214, 0, 3621, 3620, 1, 0, 0, 0, 3622, 3625, 1, 0, 0, 0, 3623, 3621, 1, 0, 0, 0, 3623, 3624, 1, 0, 0, 0, 3624, 3626, 1, 0, 0, 0, 3625, 3623, 1, 0, 0, 0, 3626, 3628, 5, 82, 0, 0, 3627, 3619, 1, 0, 0, 0, 3627, 3628, 1, 0, 0, 0, 3628, 425, 1, 0, 0, 0, 3629, 3630, 5, 405, 0, 0, 3630, 3657, 5, 499, 0, 0, 3631, 3632, 5, 343, 0, 0, 3632, 3636, 5, 257, 0, 0, 3633, 3637, 5, 499, 0, 0, 3634, 3635, 5, 492, 0, 0, 3635, 3637, 3, 684, 342, 0, 3636, 3633, 1, 0, 0, 0, 3636, 3634, 1, 0, 0, 0, 3637, 3657, 1, 0, 0, 0, 3638, 3639, 5, 62, 0, 0, 3639, 3657, 5, 499, 0, 0, 3640, 3641, 5, 63, 0, 0, 3641, 3657, 5, 501, 0, 0, 3642, 3643, 5, 344, 0, 0, 3643, 3657, 5, 499, 0, 0, 3644, 3648, 5, 341, 0, 0, 3645, 3649, 5, 499, 0, 0, 3646, 3647, 5, 492, 0, 0, 3647, 3649, 3, 684, 342, 0, 3648, 3645, 1, 0, 0, 0, 3648, 3646, 1, 0, 0, 0, 3649, 3657, 1, 0, 0, 0, 3650, 3654, 5, 342, 0, 0, 3651, 3655, 5, 499, 0, 0, 3652, 3653, 5, 492, 0, 0, 3653, 3655, 3, 684, 342, 0, 3654, 3651, 1, 0, 0, 0, 3654, 3652, 1, 0, 0, 0, 3655, 3657, 1, 0, 0, 0, 3656, 3629, 1, 0, 0, 0, 3656, 3631, 1, 0, 0, 0, 3656, 3638, 1, 0, 0, 0, 3656, 3640, 1, 0, 0, 0, 3656, 3642, 1, 0, 0, 0, 3656, 3644, 1, 0, 0, 0, 3656, 3650, 1, 0, 0, 0, 3657, 427, 1, 0, 0, 0, 3658, 3659, 5, 345, 0, 0, 3659, 3660, 3, 686, 343, 0, 3660, 3661, 5, 419, 0, 0, 3661, 3673, 7, 25, 0, 0, 3662, 3663, 5, 359, 0, 0, 3663, 3664, 3, 686, 343, 0, 3664, 3665, 5, 491, 0, 0, 3665, 3669, 3, 102, 51, 0, 3666, 3667, 5, 290, 0, 0, 3667, 3670, 5, 499, 0, 0, 3668, 3670, 5, 283, 0, 0, 3669, 3666, 1, 0, 0, 0, 3669, 3668, 1, 0, 0, 0, 3669, 3670, 1, 0, 0, 0, 3670, 3672, 1, 0, 0, 0, 3671, 3662, 1, 0, 0, 0, 3672, 3675, 1, 0, 0, 0, 3673, 3671, 1, 0, 0, 0, 3673, 3674, 1, 0, 0, 0, 3674, 3692, 1, 0, 0, 0, 3675, 3673, 1, 0, 0, 0, 3676, 3677, 5, 76, 0, 0, 3677, 3690, 3, 684, 342, 0, 3678, 3679, 5, 346, 0, 0, 3679, 3680, 5, 485, 0, 0, 3680, 3685, 3, 430, 215, 0, 3681, 3682, 5, 483, 0, 0, 3682, 3684, 3, 430, 215, 0, 3683, 3681, 1, 0, 0, 0, 3684, 3687, 1, 0, 0, 0, 3685, 3683, 1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, 3688, 1, 0, 0, 0, 3687, 3685, 1, 0, 0, 0, 3688, 3689, 5, 486, 0, 0, 3689, 3691, 1, 0, 0, 0, 3690, 3678, 1, 0, 0, 0, 3690, 3691, 1, 0, 0, 0, 3691, 3693, 1, 0, 0, 0, 3692, 3676, 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 3694, 1, 0, 0, 0, 3694, 3695, 5, 482, 0, 0, 3695, 429, 1, 0, 0, 0, 3696, 3697, 3, 686, 343, 0, 3697, 3698, 5, 75, 0, 0, 3698, 3699, 3, 686, 343, 0, 3699, 431, 1, 0, 0, 0, 3700, 3701, 5, 37, 0, 0, 3701, 3702, 3, 684, 342, 0, 3702, 3703, 5, 405, 0, 0, 3703, 3704, 3, 102, 51, 0, 3704, 3705, 5, 290, 0, 0, 3705, 3707, 3, 688, 344, 0, 3706, 3708, 3, 434, 217, 0, 3707, 3706, 1, 0, 0, 0, 3707, 3708, 1, 0, 0, 0, 3708, 433, 1, 0, 0, 0, 3709, 3711, 3, 436, 218, 0, 3710, 3709, 1, 0, 0, 0, 3711, 3712, 1, 0, 0, 0, 3712, 3710, 1, 0, 0, 0, 3712, 3713, 1, 0, 0, 0, 3713, 435, 1, 0, 0, 0, 3714, 3715, 5, 394, 0, 0, 3715, 3716, 5, 499, 0, 0, 3716, 437, 1, 0, 0, 0, 3717, 3718, 5, 306, 0, 0, 3718, 3719, 5, 332, 0, 0, 3719, 3720, 3, 684, 342, 0, 3720, 3721, 3, 440, 220, 0, 3721, 3725, 5, 95, 0, 0, 3722, 3724, 3, 446, 223, 0, 3723, 3722, 1, 0, 0, 0, 3724, 3727, 1, 0, 0, 0, 3725, 3723, 1, 0, 0, 0, 3725, 3726, 1, 0, 0, 0, 3726, 3728, 1, 0, 0, 0, 3727, 3725, 1, 0, 0, 0, 3728, 3729, 5, 82, 0, 0, 3729, 439, 1, 0, 0, 0, 3730, 3732, 3, 442, 221, 0, 3731, 3730, 1, 0, 0, 0, 3732, 3733, 1, 0, 0, 0, 3733, 3731, 1, 0, 0, 0, 3733, 3734, 1, 0, 0, 0, 3734, 441, 1, 0, 0, 0, 3735, 3736, 5, 310, 0, 0, 3736, 3737, 5, 214, 0, 0, 3737, 3745, 5, 499, 0, 0, 3738, 3739, 5, 319, 0, 0, 3739, 3745, 5, 501, 0, 0, 3740, 3741, 5, 312, 0, 0, 3741, 3745, 3, 444, 222, 0, 3742, 3743, 5, 394, 0, 0, 3743, 3745, 5, 499, 0, 0, 3744, 3735, 1, 0, 0, 0, 3744, 3738, 1, 0, 0, 0, 3744, 3740, 1, 0, 0, 0, 3744, 3742, 1, 0, 0, 0, 3745, 443, 1, 0, 0, 0, 3746, 3747, 5, 313, 0, 0, 3747, 3748, 5, 341, 0, 0, 3748, 3749, 5, 499, 0, 0, 3749, 3750, 5, 342, 0, 0, 3750, 3755, 5, 499, 0, 0, 3751, 3752, 5, 315, 0, 0, 3752, 3755, 5, 499, 0, 0, 3753, 3755, 5, 409, 0, 0, 3754, 3746, 1, 0, 0, 0, 3754, 3751, 1, 0, 0, 0, 3754, 3753, 1, 0, 0, 0, 3755, 445, 1, 0, 0, 0, 3756, 3757, 5, 316, 0, 0, 3757, 3758, 5, 503, 0, 0, 3758, 3759, 5, 317, 0, 0, 3759, 3760, 3, 448, 224, 0, 3760, 3761, 5, 318, 0, 0, 3761, 3763, 5, 499, 0, 0, 3762, 3764, 3, 450, 225, 0, 3763, 3762, 1, 0, 0, 0, 3763, 3764, 1, 0, 0, 0, 3764, 447, 1, 0, 0, 0, 3765, 3766, 7, 13, 0, 0, 3766, 449, 1, 0, 0, 0, 3767, 3769, 3, 452, 226, 0, 3768, 3767, 1, 0, 0, 0, 3769, 3770, 1, 0, 0, 0, 3770, 3768, 1, 0, 0, 0, 3770, 3771, 1, 0, 0, 0, 3771, 451, 1, 0, 0, 0, 3772, 3773, 5, 320, 0, 0, 3773, 3781, 5, 499, 0, 0, 3774, 3775, 5, 321, 0, 0, 3775, 3781, 3, 454, 227, 0, 3776, 3777, 5, 359, 0, 0, 3777, 3781, 3, 456, 228, 0, 3778, 3779, 5, 319, 0, 0, 3779, 3781, 5, 501, 0, 0, 3780, 3772, 1, 0, 0, 0, 3780, 3774, 1, 0, 0, 0, 3780, 3776, 1, 0, 0, 0, 3780, 3778, 1, 0, 0, 0, 3781, 453, 1, 0, 0, 0, 3782, 3783, 5, 325, 0, 0, 3783, 3784, 5, 501, 0, 0, 3784, 3785, 3, 102, 51, 0, 3785, 455, 1, 0, 0, 0, 3786, 3787, 5, 503, 0, 0, 3787, 3788, 5, 491, 0, 0, 3788, 3791, 3, 102, 51, 0, 3789, 3790, 5, 284, 0, 0, 3790, 3792, 7, 26, 0, 0, 3791, 3789, 1, 0, 0, 0, 3791, 3792, 1, 0, 0, 0, 3792, 457, 1, 0, 0, 0, 3793, 3794, 5, 41, 0, 0, 3794, 3795, 5, 503, 0, 0, 3795, 3796, 5, 92, 0, 0, 3796, 3797, 3, 684, 342, 0, 3797, 3798, 5, 485, 0, 0, 3798, 3799, 3, 110, 55, 0, 3799, 3800, 5, 486, 0, 0, 3800, 459, 1, 0, 0, 0, 3801, 3802, 5, 309, 0, 0, 3802, 3803, 5, 332, 0, 0, 3803, 3804, 3, 684, 342, 0, 3804, 3805, 5, 485, 0, 0, 3805, 3810, 3, 466, 233, 0, 3806, 3807, 5, 483, 0, 0, 3807, 3809, 3, 466, 233, 0, 3808, 3806, 1, 0, 0, 0, 3809, 3812, 1, 0, 0, 0, 3810, 3808, 1, 0, 0, 0, 3810, 3811, 1, 0, 0, 0, 3811, 3813, 1, 0, 0, 0, 3812, 3810, 1, 0, 0, 0, 3813, 3815, 5, 486, 0, 0, 3814, 3816, 3, 486, 243, 0, 3815, 3814, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, 461, 1, 0, 0, 0, 3817, 3818, 5, 309, 0, 0, 3818, 3819, 5, 307, 0, 0, 3819, 3820, 3, 684, 342, 0, 3820, 3821, 5, 485, 0, 0, 3821, 3826, 3, 466, 233, 0, 3822, 3823, 5, 483, 0, 0, 3823, 3825, 3, 466, 233, 0, 3824, 3822, 1, 0, 0, 0, 3825, 3828, 1, 0, 0, 0, 3826, 3824, 1, 0, 0, 0, 3826, 3827, 1, 0, 0, 0, 3827, 3829, 1, 0, 0, 0, 3828, 3826, 1, 0, 0, 0, 3829, 3831, 5, 486, 0, 0, 3830, 3832, 3, 470, 235, 0, 3831, 3830, 1, 0, 0, 0, 3831, 3832, 1, 0, 0, 0, 3832, 3841, 1, 0, 0, 0, 3833, 3837, 5, 487, 0, 0, 3834, 3836, 3, 474, 237, 0, 3835, 3834, 1, 0, 0, 0, 3836, 3839, 1, 0, 0, 0, 3837, 3835, 1, 0, 0, 0, 3837, 3838, 1, 0, 0, 0, 3838, 3840, 1, 0, 0, 0, 3839, 3837, 1, 0, 0, 0, 3840, 3842, 5, 488, 0, 0, 3841, 3833, 1, 0, 0, 0, 3841, 3842, 1, 0, 0, 0, 3842, 463, 1, 0, 0, 0, 3843, 3853, 5, 499, 0, 0, 3844, 3853, 5, 501, 0, 0, 3845, 3853, 5, 291, 0, 0, 3846, 3853, 5, 292, 0, 0, 3847, 3849, 5, 30, 0, 0, 3848, 3850, 3, 684, 342, 0, 3849, 3848, 1, 0, 0, 0, 3849, 3850, 1, 0, 0, 0, 3850, 3853, 1, 0, 0, 0, 3851, 3853, 3, 684, 342, 0, 3852, 3843, 1, 0, 0, 0, 3852, 3844, 1, 0, 0, 0, 3852, 3845, 1, 0, 0, 0, 3852, 3846, 1, 0, 0, 0, 3852, 3847, 1, 0, 0, 0, 3852, 3851, 1, 0, 0, 0, 3853, 465, 1, 0, 0, 0, 3854, 3855, 3, 686, 343, 0, 3855, 3856, 5, 491, 0, 0, 3856, 3857, 3, 464, 232, 0, 3857, 467, 1, 0, 0, 0, 3858, 3859, 3, 686, 343, 0, 3859, 3860, 5, 472, 0, 0, 3860, 3861, 3, 464, 232, 0, 3861, 469, 1, 0, 0, 0, 3862, 3863, 5, 312, 0, 0, 3863, 3868, 3, 472, 236, 0, 3864, 3865, 5, 483, 0, 0, 3865, 3867, 3, 472, 236, 0, 3866, 3864, 1, 0, 0, 0, 3867, 3870, 1, 0, 0, 0, 3868, 3866, 1, 0, 0, 0, 3868, 3869, 1, 0, 0, 0, 3869, 471, 1, 0, 0, 0, 3870, 3868, 1, 0, 0, 0, 3871, 3880, 5, 313, 0, 0, 3872, 3880, 5, 337, 0, 0, 3873, 3880, 5, 338, 0, 0, 3874, 3876, 5, 30, 0, 0, 3875, 3877, 3, 684, 342, 0, 3876, 3875, 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, 3880, 1, 0, 0, 0, 3878, 3880, 5, 503, 0, 0, 3879, 3871, 1, 0, 0, 0, 3879, 3872, 1, 0, 0, 0, 3879, 3873, 1, 0, 0, 0, 3879, 3874, 1, 0, 0, 0, 3879, 3878, 1, 0, 0, 0, 3880, 473, 1, 0, 0, 0, 3881, 3882, 5, 334, 0, 0, 3882, 3883, 5, 23, 0, 0, 3883, 3886, 3, 684, 342, 0, 3884, 3885, 5, 75, 0, 0, 3885, 3887, 5, 499, 0, 0, 3886, 3884, 1, 0, 0, 0, 3886, 3887, 1, 0, 0, 0, 3887, 3899, 1, 0, 0, 0, 3888, 3889, 5, 485, 0, 0, 3889, 3894, 3, 466, 233, 0, 3890, 3891, 5, 483, 0, 0, 3891, 3893, 3, 466, 233, 0, 3892, 3890, 1, 0, 0, 0, 3893, 3896, 1, 0, 0, 0, 3894, 3892, 1, 0, 0, 0, 3894, 3895, 1, 0, 0, 0, 3895, 3897, 1, 0, 0, 0, 3896, 3894, 1, 0, 0, 0, 3897, 3898, 5, 486, 0, 0, 3898, 3900, 1, 0, 0, 0, 3899, 3888, 1, 0, 0, 0, 3899, 3900, 1, 0, 0, 0, 3900, 3902, 1, 0, 0, 0, 3901, 3903, 3, 476, 238, 0, 3902, 3901, 1, 0, 0, 0, 3902, 3903, 1, 0, 0, 0, 3903, 3905, 1, 0, 0, 0, 3904, 3906, 5, 482, 0, 0, 3905, 3904, 1, 0, 0, 0, 3905, 3906, 1, 0, 0, 0, 3906, 475, 1, 0, 0, 0, 3907, 3908, 5, 335, 0, 0, 3908, 3918, 5, 485, 0, 0, 3909, 3919, 5, 477, 0, 0, 3910, 3915, 3, 478, 239, 0, 3911, 3912, 5, 483, 0, 0, 3912, 3914, 3, 478, 239, 0, 3913, 3911, 1, 0, 0, 0, 3914, 3917, 1, 0, 0, 0, 3915, 3913, 1, 0, 0, 0, 3915, 3916, 1, 0, 0, 0, 3916, 3919, 1, 0, 0, 0, 3917, 3915, 1, 0, 0, 0, 3918, 3909, 1, 0, 0, 0, 3918, 3910, 1, 0, 0, 0, 3919, 3920, 1, 0, 0, 0, 3920, 3921, 5, 486, 0, 0, 3921, 477, 1, 0, 0, 0, 3922, 3925, 5, 503, 0, 0, 3923, 3924, 5, 75, 0, 0, 3924, 3926, 5, 499, 0, 0, 3925, 3923, 1, 0, 0, 0, 3925, 3926, 1, 0, 0, 0, 3926, 3928, 1, 0, 0, 0, 3927, 3929, 3, 480, 240, 0, 3928, 3927, 1, 0, 0, 0, 3928, 3929, 1, 0, 0, 0, 3929, 479, 1, 0, 0, 0, 3930, 3931, 5, 485, 0, 0, 3931, 3936, 5, 503, 0, 0, 3932, 3933, 5, 483, 0, 0, 3933, 3935, 5, 503, 0, 0, 3934, 3932, 1, 0, 0, 0, 3935, 3938, 1, 0, 0, 0, 3936, 3934, 1, 0, 0, 0, 3936, 3937, 1, 0, 0, 0, 3937, 3939, 1, 0, 0, 0, 3938, 3936, 1, 0, 0, 0, 3939, 3940, 5, 486, 0, 0, 3940, 481, 1, 0, 0, 0, 3941, 3942, 5, 26, 0, 0, 3942, 3943, 5, 23, 0, 0, 3943, 3944, 3, 684, 342, 0, 3944, 3945, 5, 70, 0, 0, 3945, 3946, 5, 309, 0, 0, 3946, 3947, 5, 332, 0, 0, 3947, 3948, 3, 684, 342, 0, 3948, 3949, 5, 485, 0, 0, 3949, 3954, 3, 466, 233, 0, 3950, 3951, 5, 483, 0, 0, 3951, 3953, 3, 466, 233, 0, 3952, 3950, 1, 0, 0, 0, 3953, 3956, 1, 0, 0, 0, 3954, 3952, 1, 0, 0, 0, 3954, 3955, 1, 0, 0, 0, 3955, 3957, 1, 0, 0, 0, 3956, 3954, 1, 0, 0, 0, 3957, 3963, 5, 486, 0, 0, 3958, 3960, 5, 485, 0, 0, 3959, 3961, 3, 94, 47, 0, 3960, 3959, 1, 0, 0, 0, 3960, 3961, 1, 0, 0, 0, 3961, 3962, 1, 0, 0, 0, 3962, 3964, 5, 486, 0, 0, 3963, 3958, 1, 0, 0, 0, 3963, 3964, 1, 0, 0, 0, 3964, 483, 1, 0, 0, 0, 3965, 3968, 5, 362, 0, 0, 3966, 3969, 3, 684, 342, 0, 3967, 3969, 5, 503, 0, 0, 3968, 3966, 1, 0, 0, 0, 3968, 3967, 1, 0, 0, 0, 3969, 3973, 1, 0, 0, 0, 3970, 3972, 3, 28, 14, 0, 3971, 3970, 1, 0, 0, 0, 3972, 3975, 1, 0, 0, 0, 3973, 3971, 1, 0, 0, 0, 3973, 3974, 1, 0, 0, 0, 3974, 485, 1, 0, 0, 0, 3975, 3973, 1, 0, 0, 0, 3976, 3977, 5, 361, 0, 0, 3977, 3978, 5, 485, 0, 0, 3978, 3983, 3, 488, 244, 0, 3979, 3980, 5, 483, 0, 0, 3980, 3982, 3, 488, 244, 0, 3981, 3979, 1, 0, 0, 0, 3982, 3985, 1, 0, 0, 0, 3983, 3981, 1, 0, 0, 0, 3983, 3984, 1, 0, 0, 0, 3984, 3986, 1, 0, 0, 0, 3985, 3983, 1, 0, 0, 0, 3986, 3987, 5, 486, 0, 0, 3987, 487, 1, 0, 0, 0, 3988, 3989, 5, 499, 0, 0, 3989, 3990, 5, 491, 0, 0, 3990, 3991, 3, 464, 232, 0, 3991, 489, 1, 0, 0, 0, 3992, 3993, 5, 425, 0, 0, 3993, 3994, 5, 426, 0, 0, 3994, 3995, 5, 307, 0, 0, 3995, 3996, 3, 684, 342, 0, 3996, 3997, 5, 485, 0, 0, 3997, 4002, 3, 466, 233, 0, 3998, 3999, 5, 483, 0, 0, 3999, 4001, 3, 466, 233, 0, 4000, 3998, 1, 0, 0, 0, 4001, 4004, 1, 0, 0, 0, 4002, 4000, 1, 0, 0, 0, 4002, 4003, 1, 0, 0, 0, 4003, 4005, 1, 0, 0, 0, 4004, 4002, 1, 0, 0, 0, 4005, 4006, 5, 486, 0, 0, 4006, 4008, 5, 487, 0, 0, 4007, 4009, 3, 492, 246, 0, 4008, 4007, 1, 0, 0, 0, 4009, 4010, 1, 0, 0, 0, 4010, 4008, 1, 0, 0, 0, 4010, 4011, 1, 0, 0, 0, 4011, 4012, 1, 0, 0, 0, 4012, 4013, 5, 488, 0, 0, 4013, 491, 1, 0, 0, 0, 4014, 4015, 5, 393, 0, 0, 4015, 4016, 5, 503, 0, 0, 4016, 4017, 5, 485, 0, 0, 4017, 4022, 3, 494, 247, 0, 4018, 4019, 5, 483, 0, 0, 4019, 4021, 3, 494, 247, 0, 4020, 4018, 1, 0, 0, 0, 4021, 4024, 1, 0, 0, 0, 4022, 4020, 1, 0, 0, 0, 4022, 4023, 1, 0, 0, 0, 4023, 4025, 1, 0, 0, 0, 4024, 4022, 1, 0, 0, 0, 4025, 4026, 5, 486, 0, 0, 4026, 4029, 7, 27, 0, 0, 4027, 4028, 5, 23, 0, 0, 4028, 4030, 3, 684, 342, 0, 4029, 4027, 1, 0, 0, 0, 4029, 4030, 1, 0, 0, 0, 4030, 4033, 1, 0, 0, 0, 4031, 4032, 5, 30, 0, 0, 4032, 4034, 3, 684, 342, 0, 4033, 4031, 1, 0, 0, 0, 4033, 4034, 1, 0, 0, 0, 4034, 4035, 1, 0, 0, 0, 4035, 4036, 5, 482, 0, 0, 4036, 493, 1, 0, 0, 0, 4037, 4038, 5, 503, 0, 0, 4038, 4039, 5, 491, 0, 0, 4039, 4040, 3, 102, 51, 0, 4040, 495, 1, 0, 0, 0, 4041, 4042, 5, 32, 0, 0, 4042, 4047, 3, 684, 342, 0, 4043, 4044, 5, 359, 0, 0, 4044, 4045, 5, 502, 0, 0, 4045, 4046, 5, 491, 0, 0, 4046, 4048, 3, 684, 342, 0, 4047, 4043, 1, 0, 0, 0, 4047, 4048, 1, 0, 0, 0, 4048, 4051, 1, 0, 0, 0, 4049, 4050, 5, 466, 0, 0, 4050, 4052, 5, 499, 0, 0, 4051, 4049, 1, 0, 0, 0, 4051, 4052, 1, 0, 0, 0, 4052, 4055, 1, 0, 0, 0, 4053, 4054, 5, 465, 0, 0, 4054, 4056, 5, 499, 0, 0, 4055, 4053, 1, 0, 0, 0, 4055, 4056, 1, 0, 0, 0, 4056, 4060, 1, 0, 0, 0, 4057, 4058, 5, 352, 0, 0, 4058, 4059, 5, 442, 0, 0, 4059, 4061, 7, 28, 0, 0, 4060, 4057, 1, 0, 0, 0, 4060, 4061, 1, 0, 0, 0, 4061, 4065, 1, 0, 0, 0, 4062, 4063, 5, 453, 0, 0, 4063, 4064, 5, 33, 0, 0, 4064, 4066, 3, 684, 342, 0, 4065, 4062, 1, 0, 0, 0, 4065, 4066, 1, 0, 0, 0, 4066, 4070, 1, 0, 0, 0, 4067, 4068, 5, 452, 0, 0, 4068, 4069, 5, 263, 0, 0, 4069, 4071, 5, 499, 0, 0, 4070, 4067, 1, 0, 0, 0, 4070, 4071, 1, 0, 0, 0, 4071, 4072, 1, 0, 0, 0, 4072, 4073, 5, 95, 0, 0, 4073, 4074, 3, 498, 249, 0, 4074, 4075, 5, 82, 0, 0, 4075, 4077, 5, 32, 0, 0, 4076, 4078, 5, 482, 0, 0, 4077, 4076, 1, 0, 0, 0, 4077, 4078, 1, 0, 0, 0, 4078, 4080, 1, 0, 0, 0, 4079, 4081, 5, 478, 0, 0, 4080, 4079, 1, 0, 0, 0, 4080, 4081, 1, 0, 0, 0, 4081, 497, 1, 0, 0, 0, 4082, 4084, 3, 500, 250, 0, 4083, 4082, 1, 0, 0, 0, 4084, 4087, 1, 0, 0, 0, 4085, 4083, 1, 0, 0, 0, 4085, 4086, 1, 0, 0, 0, 4086, 499, 1, 0, 0, 0, 4087, 4085, 1, 0, 0, 0, 4088, 4089, 3, 502, 251, 0, 4089, 4090, 5, 482, 0, 0, 4090, 4116, 1, 0, 0, 0, 4091, 4092, 3, 508, 254, 0, 4092, 4093, 5, 482, 0, 0, 4093, 4116, 1, 0, 0, 0, 4094, 4095, 3, 512, 256, 0, 4095, 4096, 5, 482, 0, 0, 4096, 4116, 1, 0, 0, 0, 4097, 4098, 3, 514, 257, 0, 4098, 4099, 5, 482, 0, 0, 4099, 4116, 1, 0, 0, 0, 4100, 4101, 3, 518, 259, 0, 4101, 4102, 5, 482, 0, 0, 4102, 4116, 1, 0, 0, 0, 4103, 4104, 3, 522, 261, 0, 4104, 4105, 5, 482, 0, 0, 4105, 4116, 1, 0, 0, 0, 4106, 4107, 3, 524, 262, 0, 4107, 4108, 5, 482, 0, 0, 4108, 4116, 1, 0, 0, 0, 4109, 4110, 3, 526, 263, 0, 4110, 4111, 5, 482, 0, 0, 4111, 4116, 1, 0, 0, 0, 4112, 4113, 3, 528, 264, 0, 4113, 4114, 5, 482, 0, 0, 4114, 4116, 1, 0, 0, 0, 4115, 4088, 1, 0, 0, 0, 4115, 4091, 1, 0, 0, 0, 4115, 4094, 1, 0, 0, 0, 4115, 4097, 1, 0, 0, 0, 4115, 4100, 1, 0, 0, 0, 4115, 4103, 1, 0, 0, 0, 4115, 4106, 1, 0, 0, 0, 4115, 4109, 1, 0, 0, 0, 4115, 4112, 1, 0, 0, 0, 4116, 501, 1, 0, 0, 0, 4117, 4118, 5, 443, 0, 0, 4118, 4119, 5, 444, 0, 0, 4119, 4120, 5, 503, 0, 0, 4120, 4123, 5, 499, 0, 0, 4121, 4122, 5, 33, 0, 0, 4122, 4124, 3, 684, 342, 0, 4123, 4121, 1, 0, 0, 0, 4123, 4124, 1, 0, 0, 0, 4124, 4128, 1, 0, 0, 0, 4125, 4126, 5, 448, 0, 0, 4126, 4127, 5, 30, 0, 0, 4127, 4129, 3, 684, 342, 0, 4128, 4125, 1, 0, 0, 0, 4128, 4129, 1, 0, 0, 0, 4129, 4133, 1, 0, 0, 0, 4130, 4131, 5, 448, 0, 0, 4131, 4132, 5, 303, 0, 0, 4132, 4134, 5, 499, 0, 0, 4133, 4130, 1, 0, 0, 0, 4133, 4134, 1, 0, 0, 0, 4134, 4137, 1, 0, 0, 0, 4135, 4136, 5, 23, 0, 0, 4136, 4138, 3, 684, 342, 0, 4137, 4135, 1, 0, 0, 0, 4137, 4138, 1, 0, 0, 0, 4138, 4142, 1, 0, 0, 0, 4139, 4140, 5, 452, 0, 0, 4140, 4141, 5, 263, 0, 0, 4141, 4143, 5, 499, 0, 0, 4142, 4139, 1, 0, 0, 0, 4142, 4143, 1, 0, 0, 0, 4143, 4146, 1, 0, 0, 0, 4144, 4145, 5, 465, 0, 0, 4145, 4147, 5, 499, 0, 0, 4146, 4144, 1, 0, 0, 0, 4146, 4147, 1, 0, 0, 0, 4147, 4154, 1, 0, 0, 0, 4148, 4150, 5, 447, 0, 0, 4149, 4151, 3, 506, 253, 0, 4150, 4149, 1, 0, 0, 0, 4151, 4152, 1, 0, 0, 0, 4152, 4150, 1, 0, 0, 0, 4152, 4153, 1, 0, 0, 0, 4153, 4155, 1, 0, 0, 0, 4154, 4148, 1, 0, 0, 0, 4154, 4155, 1, 0, 0, 0, 4155, 4163, 1, 0, 0, 0, 4156, 4157, 5, 458, 0, 0, 4157, 4159, 5, 426, 0, 0, 4158, 4160, 3, 504, 252, 0, 4159, 4158, 1, 0, 0, 0, 4160, 4161, 1, 0, 0, 0, 4161, 4159, 1, 0, 0, 0, 4161, 4162, 1, 0, 0, 0, 4162, 4164, 1, 0, 0, 0, 4163, 4156, 1, 0, 0, 0, 4163, 4164, 1, 0, 0, 0, 4164, 4215, 1, 0, 0, 0, 4165, 4166, 5, 461, 0, 0, 4166, 4167, 5, 443, 0, 0, 4167, 4168, 5, 444, 0, 0, 4168, 4169, 5, 503, 0, 0, 4169, 4172, 5, 499, 0, 0, 4170, 4171, 5, 33, 0, 0, 4171, 4173, 3, 684, 342, 0, 4172, 4170, 1, 0, 0, 0, 4172, 4173, 1, 0, 0, 0, 4173, 4177, 1, 0, 0, 0, 4174, 4175, 5, 448, 0, 0, 4175, 4176, 5, 30, 0, 0, 4176, 4178, 3, 684, 342, 0, 4177, 4174, 1, 0, 0, 0, 4177, 4178, 1, 0, 0, 0, 4178, 4182, 1, 0, 0, 0, 4179, 4180, 5, 448, 0, 0, 4180, 4181, 5, 303, 0, 0, 4181, 4183, 5, 499, 0, 0, 4182, 4179, 1, 0, 0, 0, 4182, 4183, 1, 0, 0, 0, 4183, 4186, 1, 0, 0, 0, 4184, 4185, 5, 23, 0, 0, 4185, 4187, 3, 684, 342, 0, 4186, 4184, 1, 0, 0, 0, 4186, 4187, 1, 0, 0, 0, 4187, 4191, 1, 0, 0, 0, 4188, 4189, 5, 452, 0, 0, 4189, 4190, 5, 263, 0, 0, 4190, 4192, 5, 499, 0, 0, 4191, 4188, 1, 0, 0, 0, 4191, 4192, 1, 0, 0, 0, 4192, 4195, 1, 0, 0, 0, 4193, 4194, 5, 465, 0, 0, 4194, 4196, 5, 499, 0, 0, 4195, 4193, 1, 0, 0, 0, 4195, 4196, 1, 0, 0, 0, 4196, 4203, 1, 0, 0, 0, 4197, 4199, 5, 447, 0, 0, 4198, 4200, 3, 506, 253, 0, 4199, 4198, 1, 0, 0, 0, 4200, 4201, 1, 0, 0, 0, 4201, 4199, 1, 0, 0, 0, 4201, 4202, 1, 0, 0, 0, 4202, 4204, 1, 0, 0, 0, 4203, 4197, 1, 0, 0, 0, 4203, 4204, 1, 0, 0, 0, 4204, 4212, 1, 0, 0, 0, 4205, 4206, 5, 458, 0, 0, 4206, 4208, 5, 426, 0, 0, 4207, 4209, 3, 504, 252, 0, 4208, 4207, 1, 0, 0, 0, 4209, 4210, 1, 0, 0, 0, 4210, 4208, 1, 0, 0, 0, 4210, 4211, 1, 0, 0, 0, 4211, 4213, 1, 0, 0, 0, 4212, 4205, 1, 0, 0, 0, 4212, 4213, 1, 0, 0, 0, 4213, 4215, 1, 0, 0, 0, 4214, 4117, 1, 0, 0, 0, 4214, 4165, 1, 0, 0, 0, 4215, 503, 1, 0, 0, 0, 4216, 4217, 5, 459, 0, 0, 4217, 4219, 5, 450, 0, 0, 4218, 4220, 5, 499, 0, 0, 4219, 4218, 1, 0, 0, 0, 4219, 4220, 1, 0, 0, 0, 4220, 4225, 1, 0, 0, 0, 4221, 4222, 5, 487, 0, 0, 4222, 4223, 3, 498, 249, 0, 4223, 4224, 5, 488, 0, 0, 4224, 4226, 1, 0, 0, 0, 4225, 4221, 1, 0, 0, 0, 4225, 4226, 1, 0, 0, 0, 4226, 4250, 1, 0, 0, 0, 4227, 4228, 5, 460, 0, 0, 4228, 4229, 5, 459, 0, 0, 4229, 4231, 5, 450, 0, 0, 4230, 4232, 5, 499, 0, 0, 4231, 4230, 1, 0, 0, 0, 4231, 4232, 1, 0, 0, 0, 4232, 4237, 1, 0, 0, 0, 4233, 4234, 5, 487, 0, 0, 4234, 4235, 3, 498, 249, 0, 4235, 4236, 5, 488, 0, 0, 4236, 4238, 1, 0, 0, 0, 4237, 4233, 1, 0, 0, 0, 4237, 4238, 1, 0, 0, 0, 4238, 4250, 1, 0, 0, 0, 4239, 4241, 5, 450, 0, 0, 4240, 4242, 5, 499, 0, 0, 4241, 4240, 1, 0, 0, 0, 4241, 4242, 1, 0, 0, 0, 4242, 4247, 1, 0, 0, 0, 4243, 4244, 5, 487, 0, 0, 4244, 4245, 3, 498, 249, 0, 4245, 4246, 5, 488, 0, 0, 4246, 4248, 1, 0, 0, 0, 4247, 4243, 1, 0, 0, 0, 4247, 4248, 1, 0, 0, 0, 4248, 4250, 1, 0, 0, 0, 4249, 4216, 1, 0, 0, 0, 4249, 4227, 1, 0, 0, 0, 4249, 4239, 1, 0, 0, 0, 4250, 505, 1, 0, 0, 0, 4251, 4252, 5, 499, 0, 0, 4252, 4253, 5, 487, 0, 0, 4253, 4254, 3, 498, 249, 0, 4254, 4255, 5, 488, 0, 0, 4255, 507, 1, 0, 0, 0, 4256, 4257, 5, 112, 0, 0, 4257, 4258, 5, 30, 0, 0, 4258, 4261, 3, 684, 342, 0, 4259, 4260, 5, 394, 0, 0, 4260, 4262, 5, 499, 0, 0, 4261, 4259, 1, 0, 0, 0, 4261, 4262, 1, 0, 0, 0, 4262, 4275, 1, 0, 0, 0, 4263, 4264, 5, 137, 0, 0, 4264, 4265, 5, 485, 0, 0, 4265, 4270, 3, 510, 255, 0, 4266, 4267, 5, 483, 0, 0, 4267, 4269, 3, 510, 255, 0, 4268, 4266, 1, 0, 0, 0, 4269, 4272, 1, 0, 0, 0, 4270, 4268, 1, 0, 0, 0, 4270, 4271, 1, 0, 0, 0, 4271, 4273, 1, 0, 0, 0, 4272, 4270, 1, 0, 0, 0, 4273, 4274, 5, 486, 0, 0, 4274, 4276, 1, 0, 0, 0, 4275, 4263, 1, 0, 0, 0, 4275, 4276, 1, 0, 0, 0, 4276, 4283, 1, 0, 0, 0, 4277, 4279, 5, 447, 0, 0, 4278, 4280, 3, 516, 258, 0, 4279, 4278, 1, 0, 0, 0, 4280, 4281, 1, 0, 0, 0, 4281, 4279, 1, 0, 0, 0, 4281, 4282, 1, 0, 0, 0, 4282, 4284, 1, 0, 0, 0, 4283, 4277, 1, 0, 0, 0, 4283, 4284, 1, 0, 0, 0, 4284, 4292, 1, 0, 0, 0, 4285, 4286, 5, 458, 0, 0, 4286, 4288, 5, 426, 0, 0, 4287, 4289, 3, 504, 252, 0, 4288, 4287, 1, 0, 0, 0, 4289, 4290, 1, 0, 0, 0, 4290, 4288, 1, 0, 0, 0, 4290, 4291, 1, 0, 0, 0, 4291, 4293, 1, 0, 0, 0, 4292, 4285, 1, 0, 0, 0, 4292, 4293, 1, 0, 0, 0, 4293, 509, 1, 0, 0, 0, 4294, 4295, 3, 684, 342, 0, 4295, 4296, 5, 472, 0, 0, 4296, 4297, 5, 499, 0, 0, 4297, 511, 1, 0, 0, 0, 4298, 4299, 5, 112, 0, 0, 4299, 4300, 5, 32, 0, 0, 4300, 4303, 3, 684, 342, 0, 4301, 4302, 5, 394, 0, 0, 4302, 4304, 5, 499, 0, 0, 4303, 4301, 1, 0, 0, 0, 4303, 4304, 1, 0, 0, 0, 4304, 4317, 1, 0, 0, 0, 4305, 4306, 5, 137, 0, 0, 4306, 4307, 5, 485, 0, 0, 4307, 4312, 3, 510, 255, 0, 4308, 4309, 5, 483, 0, 0, 4309, 4311, 3, 510, 255, 0, 4310, 4308, 1, 0, 0, 0, 4311, 4314, 1, 0, 0, 0, 4312, 4310, 1, 0, 0, 0, 4312, 4313, 1, 0, 0, 0, 4313, 4315, 1, 0, 0, 0, 4314, 4312, 1, 0, 0, 0, 4315, 4316, 5, 486, 0, 0, 4316, 4318, 1, 0, 0, 0, 4317, 4305, 1, 0, 0, 0, 4317, 4318, 1, 0, 0, 0, 4318, 513, 1, 0, 0, 0, 4319, 4321, 5, 445, 0, 0, 4320, 4322, 5, 499, 0, 0, 4321, 4320, 1, 0, 0, 0, 4321, 4322, 1, 0, 0, 0, 4322, 4325, 1, 0, 0, 0, 4323, 4324, 5, 394, 0, 0, 4324, 4326, 5, 499, 0, 0, 4325, 4323, 1, 0, 0, 0, 4325, 4326, 1, 0, 0, 0, 4326, 4333, 1, 0, 0, 0, 4327, 4329, 5, 447, 0, 0, 4328, 4330, 3, 516, 258, 0, 4329, 4328, 1, 0, 0, 0, 4330, 4331, 1, 0, 0, 0, 4331, 4329, 1, 0, 0, 0, 4331, 4332, 1, 0, 0, 0, 4332, 4334, 1, 0, 0, 0, 4333, 4327, 1, 0, 0, 0, 4333, 4334, 1, 0, 0, 0, 4334, 515, 1, 0, 0, 0, 4335, 4336, 7, 29, 0, 0, 4336, 4337, 5, 495, 0, 0, 4337, 4338, 5, 487, 0, 0, 4338, 4339, 3, 498, 249, 0, 4339, 4340, 5, 488, 0, 0, 4340, 517, 1, 0, 0, 0, 4341, 4342, 5, 455, 0, 0, 4342, 4345, 5, 446, 0, 0, 4343, 4344, 5, 394, 0, 0, 4344, 4346, 5, 499, 0, 0, 4345, 4343, 1, 0, 0, 0, 4345, 4346, 1, 0, 0, 0, 4346, 4348, 1, 0, 0, 0, 4347, 4349, 3, 520, 260, 0, 4348, 4347, 1, 0, 0, 0, 4349, 4350, 1, 0, 0, 0, 4350, 4348, 1, 0, 0, 0, 4350, 4351, 1, 0, 0, 0, 4351, 519, 1, 0, 0, 0, 4352, 4353, 5, 318, 0, 0, 4353, 4354, 5, 501, 0, 0, 4354, 4355, 5, 487, 0, 0, 4355, 4356, 3, 498, 249, 0, 4356, 4357, 5, 488, 0, 0, 4357, 521, 1, 0, 0, 0, 4358, 4359, 5, 451, 0, 0, 4359, 4360, 5, 411, 0, 0, 4360, 4363, 5, 503, 0, 0, 4361, 4362, 5, 394, 0, 0, 4362, 4364, 5, 499, 0, 0, 4363, 4361, 1, 0, 0, 0, 4363, 4364, 1, 0, 0, 0, 4364, 523, 1, 0, 0, 0, 4365, 4366, 5, 456, 0, 0, 4366, 4367, 5, 414, 0, 0, 4367, 4369, 5, 450, 0, 0, 4368, 4370, 5, 499, 0, 0, 4369, 4368, 1, 0, 0, 0, 4369, 4370, 1, 0, 0, 0, 4370, 4373, 1, 0, 0, 0, 4371, 4372, 5, 394, 0, 0, 4372, 4374, 5, 499, 0, 0, 4373, 4371, 1, 0, 0, 0, 4373, 4374, 1, 0, 0, 0, 4374, 525, 1, 0, 0, 0, 4375, 4376, 5, 456, 0, 0, 4376, 4377, 5, 414, 0, 0, 4377, 4380, 5, 449, 0, 0, 4378, 4379, 5, 394, 0, 0, 4379, 4381, 5, 499, 0, 0, 4380, 4378, 1, 0, 0, 0, 4380, 4381, 1, 0, 0, 0, 4381, 4389, 1, 0, 0, 0, 4382, 4383, 5, 458, 0, 0, 4383, 4385, 5, 426, 0, 0, 4384, 4386, 3, 504, 252, 0, 4385, 4384, 1, 0, 0, 0, 4386, 4387, 1, 0, 0, 0, 4387, 4385, 1, 0, 0, 0, 4387, 4388, 1, 0, 0, 0, 4388, 4390, 1, 0, 0, 0, 4389, 4382, 1, 0, 0, 0, 4389, 4390, 1, 0, 0, 0, 4390, 527, 1, 0, 0, 0, 4391, 4392, 5, 457, 0, 0, 4392, 4393, 5, 499, 0, 0, 4393, 529, 1, 0, 0, 0, 4394, 4395, 3, 532, 266, 0, 4395, 4400, 3, 534, 267, 0, 4396, 4397, 5, 483, 0, 0, 4397, 4399, 3, 534, 267, 0, 4398, 4396, 1, 0, 0, 0, 4399, 4402, 1, 0, 0, 0, 4400, 4398, 1, 0, 0, 0, 4400, 4401, 1, 0, 0, 0, 4401, 4423, 1, 0, 0, 0, 4402, 4400, 1, 0, 0, 0, 4403, 4404, 5, 37, 0, 0, 4404, 4405, 5, 499, 0, 0, 4405, 4406, 5, 406, 0, 0, 4406, 4410, 3, 536, 268, 0, 4407, 4408, 5, 284, 0, 0, 4408, 4409, 5, 429, 0, 0, 4409, 4411, 5, 499, 0, 0, 4410, 4407, 1, 0, 0, 0, 4410, 4411, 1, 0, 0, 0, 4411, 4423, 1, 0, 0, 0, 4412, 4413, 5, 429, 0, 0, 4413, 4414, 5, 499, 0, 0, 4414, 4419, 3, 534, 267, 0, 4415, 4416, 5, 483, 0, 0, 4416, 4418, 3, 534, 267, 0, 4417, 4415, 1, 0, 0, 0, 4418, 4421, 1, 0, 0, 0, 4419, 4417, 1, 0, 0, 0, 4419, 4420, 1, 0, 0, 0, 4420, 4423, 1, 0, 0, 0, 4421, 4419, 1, 0, 0, 0, 4422, 4394, 1, 0, 0, 0, 4422, 4403, 1, 0, 0, 0, 4422, 4412, 1, 0, 0, 0, 4423, 531, 1, 0, 0, 0, 4424, 4425, 7, 30, 0, 0, 4425, 533, 1, 0, 0, 0, 4426, 4427, 5, 503, 0, 0, 4427, 4428, 5, 472, 0, 0, 4428, 4429, 3, 536, 268, 0, 4429, 535, 1, 0, 0, 0, 4430, 4435, 5, 499, 0, 0, 4431, 4435, 5, 501, 0, 0, 4432, 4435, 3, 692, 346, 0, 4433, 4435, 3, 684, 342, 0, 4434, 4430, 1, 0, 0, 0, 4434, 4431, 1, 0, 0, 0, 4434, 4432, 1, 0, 0, 0, 4434, 4433, 1, 0, 0, 0, 4435, 537, 1, 0, 0, 0, 4436, 4441, 3, 540, 270, 0, 4437, 4441, 3, 552, 276, 0, 4438, 4441, 3, 554, 277, 0, 4439, 4441, 3, 560, 280, 0, 4440, 4436, 1, 0, 0, 0, 4440, 4437, 1, 0, 0, 0, 4440, 4438, 1, 0, 0, 0, 4440, 4439, 1, 0, 0, 0, 4441, 539, 1, 0, 0, 0, 4442, 4443, 5, 64, 0, 0, 4443, 4769, 5, 368, 0, 0, 4444, 4445, 5, 64, 0, 0, 4445, 4451, 5, 369, 0, 0, 4446, 4449, 5, 284, 0, 0, 4447, 4450, 3, 684, 342, 0, 4448, 4450, 5, 503, 0, 0, 4449, 4447, 1, 0, 0, 0, 4449, 4448, 1, 0, 0, 0, 4450, 4452, 1, 0, 0, 0, 4451, 4446, 1, 0, 0, 0, 4451, 4452, 1, 0, 0, 0, 4452, 4769, 1, 0, 0, 0, 4453, 4454, 5, 64, 0, 0, 4454, 4460, 5, 370, 0, 0, 4455, 4458, 5, 284, 0, 0, 4456, 4459, 3, 684, 342, 0, 4457, 4459, 5, 503, 0, 0, 4458, 4456, 1, 0, 0, 0, 4458, 4457, 1, 0, 0, 0, 4459, 4461, 1, 0, 0, 0, 4460, 4455, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, 4769, 1, 0, 0, 0, 4462, 4463, 5, 64, 0, 0, 4463, 4469, 5, 371, 0, 0, 4464, 4467, 5, 284, 0, 0, 4465, 4468, 3, 684, 342, 0, 4466, 4468, 5, 503, 0, 0, 4467, 4465, 1, 0, 0, 0, 4467, 4466, 1, 0, 0, 0, 4468, 4470, 1, 0, 0, 0, 4469, 4464, 1, 0, 0, 0, 4469, 4470, 1, 0, 0, 0, 4470, 4769, 1, 0, 0, 0, 4471, 4472, 5, 64, 0, 0, 4472, 4478, 5, 372, 0, 0, 4473, 4476, 5, 284, 0, 0, 4474, 4477, 3, 684, 342, 0, 4475, 4477, 5, 503, 0, 0, 4476, 4474, 1, 0, 0, 0, 4476, 4475, 1, 0, 0, 0, 4477, 4479, 1, 0, 0, 0, 4478, 4473, 1, 0, 0, 0, 4478, 4479, 1, 0, 0, 0, 4479, 4769, 1, 0, 0, 0, 4480, 4481, 5, 64, 0, 0, 4481, 4487, 5, 373, 0, 0, 4482, 4485, 5, 284, 0, 0, 4483, 4486, 3, 684, 342, 0, 4484, 4486, 5, 503, 0, 0, 4485, 4483, 1, 0, 0, 0, 4485, 4484, 1, 0, 0, 0, 4486, 4488, 1, 0, 0, 0, 4487, 4482, 1, 0, 0, 0, 4487, 4488, 1, 0, 0, 0, 4488, 4769, 1, 0, 0, 0, 4489, 4490, 5, 64, 0, 0, 4490, 4496, 5, 141, 0, 0, 4491, 4494, 5, 284, 0, 0, 4492, 4495, 3, 684, 342, 0, 4493, 4495, 5, 503, 0, 0, 4494, 4492, 1, 0, 0, 0, 4494, 4493, 1, 0, 0, 0, 4495, 4497, 1, 0, 0, 0, 4496, 4491, 1, 0, 0, 0, 4496, 4497, 1, 0, 0, 0, 4497, 4769, 1, 0, 0, 0, 4498, 4499, 5, 64, 0, 0, 4499, 4505, 5, 143, 0, 0, 4500, 4503, 5, 284, 0, 0, 4501, 4504, 3, 684, 342, 0, 4502, 4504, 5, 503, 0, 0, 4503, 4501, 1, 0, 0, 0, 4503, 4502, 1, 0, 0, 0, 4504, 4506, 1, 0, 0, 0, 4505, 4500, 1, 0, 0, 0, 4505, 4506, 1, 0, 0, 0, 4506, 4769, 1, 0, 0, 0, 4507, 4508, 5, 64, 0, 0, 4508, 4514, 5, 374, 0, 0, 4509, 4512, 5, 284, 0, 0, 4510, 4513, 3, 684, 342, 0, 4511, 4513, 5, 503, 0, 0, 4512, 4510, 1, 0, 0, 0, 4512, 4511, 1, 0, 0, 0, 4513, 4515, 1, 0, 0, 0, 4514, 4509, 1, 0, 0, 0, 4514, 4515, 1, 0, 0, 0, 4515, 4769, 1, 0, 0, 0, 4516, 4517, 5, 64, 0, 0, 4517, 4523, 5, 375, 0, 0, 4518, 4521, 5, 284, 0, 0, 4519, 4522, 3, 684, 342, 0, 4520, 4522, 5, 503, 0, 0, 4521, 4519, 1, 0, 0, 0, 4521, 4520, 1, 0, 0, 0, 4522, 4524, 1, 0, 0, 0, 4523, 4518, 1, 0, 0, 0, 4523, 4524, 1, 0, 0, 0, 4524, 4769, 1, 0, 0, 0, 4525, 4526, 5, 64, 0, 0, 4526, 4532, 5, 142, 0, 0, 4527, 4530, 5, 284, 0, 0, 4528, 4531, 3, 684, 342, 0, 4529, 4531, 5, 503, 0, 0, 4530, 4528, 1, 0, 0, 0, 4530, 4529, 1, 0, 0, 0, 4531, 4533, 1, 0, 0, 0, 4532, 4527, 1, 0, 0, 0, 4532, 4533, 1, 0, 0, 0, 4533, 4769, 1, 0, 0, 0, 4534, 4535, 5, 64, 0, 0, 4535, 4541, 5, 144, 0, 0, 4536, 4539, 5, 284, 0, 0, 4537, 4540, 3, 684, 342, 0, 4538, 4540, 5, 503, 0, 0, 4539, 4537, 1, 0, 0, 0, 4539, 4538, 1, 0, 0, 0, 4540, 4542, 1, 0, 0, 0, 4541, 4536, 1, 0, 0, 0, 4541, 4542, 1, 0, 0, 0, 4542, 4769, 1, 0, 0, 0, 4543, 4544, 5, 64, 0, 0, 4544, 4545, 5, 113, 0, 0, 4545, 4551, 5, 115, 0, 0, 4546, 4549, 5, 284, 0, 0, 4547, 4550, 3, 684, 342, 0, 4548, 4550, 5, 503, 0, 0, 4549, 4547, 1, 0, 0, 0, 4549, 4548, 1, 0, 0, 0, 4550, 4552, 1, 0, 0, 0, 4551, 4546, 1, 0, 0, 0, 4551, 4552, 1, 0, 0, 0, 4552, 4769, 1, 0, 0, 0, 4553, 4554, 5, 64, 0, 0, 4554, 4555, 5, 23, 0, 0, 4555, 4769, 3, 684, 342, 0, 4556, 4557, 5, 64, 0, 0, 4557, 4558, 5, 27, 0, 0, 4558, 4769, 3, 684, 342, 0, 4559, 4560, 5, 64, 0, 0, 4560, 4561, 5, 33, 0, 0, 4561, 4769, 3, 684, 342, 0, 4562, 4563, 5, 64, 0, 0, 4563, 4769, 5, 376, 0, 0, 4564, 4565, 5, 64, 0, 0, 4565, 4769, 5, 325, 0, 0, 4566, 4567, 5, 64, 0, 0, 4567, 4769, 5, 326, 0, 0, 4568, 4569, 5, 64, 0, 0, 4569, 4570, 5, 395, 0, 0, 4570, 4769, 5, 325, 0, 0, 4571, 4572, 5, 64, 0, 0, 4572, 4573, 5, 395, 0, 0, 4573, 4769, 5, 356, 0, 0, 4574, 4575, 5, 64, 0, 0, 4575, 4576, 5, 398, 0, 0, 4576, 4577, 5, 412, 0, 0, 4577, 4579, 3, 684, 342, 0, 4578, 4580, 5, 401, 0, 0, 4579, 4578, 1, 0, 0, 0, 4579, 4580, 1, 0, 0, 0, 4580, 4769, 1, 0, 0, 0, 4581, 4582, 5, 64, 0, 0, 4582, 4583, 5, 399, 0, 0, 4583, 4584, 5, 412, 0, 0, 4584, 4586, 3, 684, 342, 0, 4585, 4587, 5, 401, 0, 0, 4586, 4585, 1, 0, 0, 0, 4586, 4587, 1, 0, 0, 0, 4587, 4769, 1, 0, 0, 0, 4588, 4589, 5, 64, 0, 0, 4589, 4590, 5, 400, 0, 0, 4590, 4591, 5, 411, 0, 0, 4591, 4769, 3, 684, 342, 0, 4592, 4593, 5, 64, 0, 0, 4593, 4594, 5, 402, 0, 0, 4594, 4595, 5, 412, 0, 0, 4595, 4769, 3, 684, 342, 0, 4596, 4597, 5, 64, 0, 0, 4597, 4598, 5, 217, 0, 0, 4598, 4599, 5, 412, 0, 0, 4599, 4602, 3, 684, 342, 0, 4600, 4601, 5, 403, 0, 0, 4601, 4603, 5, 501, 0, 0, 4602, 4600, 1, 0, 0, 0, 4602, 4603, 1, 0, 0, 0, 4603, 4769, 1, 0, 0, 0, 4604, 4605, 5, 64, 0, 0, 4605, 4607, 5, 185, 0, 0, 4606, 4608, 3, 542, 271, 0, 4607, 4606, 1, 0, 0, 0, 4607, 4608, 1, 0, 0, 0, 4608, 4769, 1, 0, 0, 0, 4609, 4610, 5, 64, 0, 0, 4610, 4611, 5, 58, 0, 0, 4611, 4769, 5, 430, 0, 0, 4612, 4613, 5, 64, 0, 0, 4613, 4614, 5, 29, 0, 0, 4614, 4620, 5, 432, 0, 0, 4615, 4618, 5, 284, 0, 0, 4616, 4619, 3, 684, 342, 0, 4617, 4619, 5, 503, 0, 0, 4618, 4616, 1, 0, 0, 0, 4618, 4617, 1, 0, 0, 0, 4619, 4621, 1, 0, 0, 0, 4620, 4615, 1, 0, 0, 0, 4620, 4621, 1, 0, 0, 0, 4621, 4769, 1, 0, 0, 0, 4622, 4623, 5, 64, 0, 0, 4623, 4624, 5, 443, 0, 0, 4624, 4769, 5, 432, 0, 0, 4625, 4626, 5, 64, 0, 0, 4626, 4627, 5, 438, 0, 0, 4627, 4769, 5, 468, 0, 0, 4628, 4629, 5, 64, 0, 0, 4629, 4630, 5, 441, 0, 0, 4630, 4631, 5, 92, 0, 0, 4631, 4769, 3, 684, 342, 0, 4632, 4633, 5, 64, 0, 0, 4633, 4634, 5, 441, 0, 0, 4634, 4635, 5, 92, 0, 0, 4635, 4636, 5, 30, 0, 0, 4636, 4769, 3, 684, 342, 0, 4637, 4638, 5, 64, 0, 0, 4638, 4639, 5, 441, 0, 0, 4639, 4640, 5, 92, 0, 0, 4640, 4641, 5, 33, 0, 0, 4641, 4769, 3, 684, 342, 0, 4642, 4643, 5, 64, 0, 0, 4643, 4644, 5, 441, 0, 0, 4644, 4645, 5, 92, 0, 0, 4645, 4646, 5, 32, 0, 0, 4646, 4769, 3, 684, 342, 0, 4647, 4648, 5, 64, 0, 0, 4648, 4649, 5, 430, 0, 0, 4649, 4655, 5, 439, 0, 0, 4650, 4653, 5, 284, 0, 0, 4651, 4654, 3, 684, 342, 0, 4652, 4654, 5, 503, 0, 0, 4653, 4651, 1, 0, 0, 0, 4653, 4652, 1, 0, 0, 0, 4654, 4656, 1, 0, 0, 0, 4655, 4650, 1, 0, 0, 0, 4655, 4656, 1, 0, 0, 0, 4656, 4769, 1, 0, 0, 0, 4657, 4658, 5, 64, 0, 0, 4658, 4659, 5, 309, 0, 0, 4659, 4665, 5, 333, 0, 0, 4660, 4663, 5, 284, 0, 0, 4661, 4664, 3, 684, 342, 0, 4662, 4664, 5, 503, 0, 0, 4663, 4661, 1, 0, 0, 0, 4663, 4662, 1, 0, 0, 0, 4664, 4666, 1, 0, 0, 0, 4665, 4660, 1, 0, 0, 0, 4665, 4666, 1, 0, 0, 0, 4666, 4769, 1, 0, 0, 0, 4667, 4668, 5, 64, 0, 0, 4668, 4669, 5, 309, 0, 0, 4669, 4675, 5, 308, 0, 0, 4670, 4673, 5, 284, 0, 0, 4671, 4674, 3, 684, 342, 0, 4672, 4674, 5, 503, 0, 0, 4673, 4671, 1, 0, 0, 0, 4673, 4672, 1, 0, 0, 0, 4674, 4676, 1, 0, 0, 0, 4675, 4670, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676, 4769, 1, 0, 0, 0, 4677, 4678, 5, 64, 0, 0, 4678, 4679, 5, 26, 0, 0, 4679, 4685, 5, 369, 0, 0, 4680, 4683, 5, 284, 0, 0, 4681, 4684, 3, 684, 342, 0, 4682, 4684, 5, 503, 0, 0, 4683, 4681, 1, 0, 0, 0, 4683, 4682, 1, 0, 0, 0, 4684, 4686, 1, 0, 0, 0, 4685, 4680, 1, 0, 0, 0, 4685, 4686, 1, 0, 0, 0, 4686, 4769, 1, 0, 0, 0, 4687, 4688, 5, 64, 0, 0, 4688, 4769, 5, 362, 0, 0, 4689, 4690, 5, 64, 0, 0, 4690, 4691, 5, 362, 0, 0, 4691, 4694, 5, 363, 0, 0, 4692, 4695, 3, 684, 342, 0, 4693, 4695, 5, 503, 0, 0, 4694, 4692, 1, 0, 0, 0, 4694, 4693, 1, 0, 0, 0, 4694, 4695, 1, 0, 0, 0, 4695, 4769, 1, 0, 0, 0, 4696, 4697, 5, 64, 0, 0, 4697, 4698, 5, 362, 0, 0, 4698, 4769, 5, 364, 0, 0, 4699, 4700, 5, 64, 0, 0, 4700, 4701, 5, 206, 0, 0, 4701, 4704, 5, 207, 0, 0, 4702, 4703, 5, 414, 0, 0, 4703, 4705, 3, 544, 272, 0, 4704, 4702, 1, 0, 0, 0, 4704, 4705, 1, 0, 0, 0, 4705, 4769, 1, 0, 0, 0, 4706, 4707, 5, 64, 0, 0, 4707, 4710, 5, 404, 0, 0, 4708, 4709, 5, 403, 0, 0, 4709, 4711, 5, 501, 0, 0, 4710, 4708, 1, 0, 0, 0, 4710, 4711, 1, 0, 0, 0, 4711, 4717, 1, 0, 0, 0, 4712, 4715, 5, 284, 0, 0, 4713, 4716, 3, 684, 342, 0, 4714, 4716, 5, 503, 0, 0, 4715, 4713, 1, 0, 0, 0, 4715, 4714, 1, 0, 0, 0, 4716, 4718, 1, 0, 0, 0, 4717, 4712, 1, 0, 0, 0, 4717, 4718, 1, 0, 0, 0, 4718, 4720, 1, 0, 0, 0, 4719, 4721, 5, 84, 0, 0, 4720, 4719, 1, 0, 0, 0, 4720, 4721, 1, 0, 0, 0, 4721, 4769, 1, 0, 0, 0, 4722, 4723, 5, 64, 0, 0, 4723, 4724, 5, 425, 0, 0, 4724, 4725, 5, 426, 0, 0, 4725, 4731, 5, 308, 0, 0, 4726, 4729, 5, 284, 0, 0, 4727, 4730, 3, 684, 342, 0, 4728, 4730, 5, 503, 0, 0, 4729, 4727, 1, 0, 0, 0, 4729, 4728, 1, 0, 0, 0, 4730, 4732, 1, 0, 0, 0, 4731, 4726, 1, 0, 0, 0, 4731, 4732, 1, 0, 0, 0, 4732, 4769, 1, 0, 0, 0, 4733, 4734, 5, 64, 0, 0, 4734, 4735, 5, 425, 0, 0, 4735, 4736, 5, 426, 0, 0, 4736, 4742, 5, 333, 0, 0, 4737, 4740, 5, 284, 0, 0, 4738, 4741, 3, 684, 342, 0, 4739, 4741, 5, 503, 0, 0, 4740, 4738, 1, 0, 0, 0, 4740, 4739, 1, 0, 0, 0, 4741, 4743, 1, 0, 0, 0, 4742, 4737, 1, 0, 0, 0, 4742, 4743, 1, 0, 0, 0, 4743, 4769, 1, 0, 0, 0, 4744, 4745, 5, 64, 0, 0, 4745, 4746, 5, 425, 0, 0, 4746, 4752, 5, 118, 0, 0, 4747, 4750, 5, 284, 0, 0, 4748, 4751, 3, 684, 342, 0, 4749, 4751, 5, 503, 0, 0, 4750, 4748, 1, 0, 0, 0, 4750, 4749, 1, 0, 0, 0, 4751, 4753, 1, 0, 0, 0, 4752, 4747, 1, 0, 0, 0, 4752, 4753, 1, 0, 0, 0, 4753, 4769, 1, 0, 0, 0, 4754, 4755, 5, 64, 0, 0, 4755, 4769, 5, 428, 0, 0, 4756, 4757, 5, 64, 0, 0, 4757, 4769, 5, 379, 0, 0, 4758, 4759, 5, 64, 0, 0, 4759, 4760, 5, 344, 0, 0, 4760, 4766, 5, 376, 0, 0, 4761, 4764, 5, 284, 0, 0, 4762, 4765, 3, 684, 342, 0, 4763, 4765, 5, 503, 0, 0, 4764, 4762, 1, 0, 0, 0, 4764, 4763, 1, 0, 0, 0, 4765, 4767, 1, 0, 0, 0, 4766, 4761, 1, 0, 0, 0, 4766, 4767, 1, 0, 0, 0, 4767, 4769, 1, 0, 0, 0, 4768, 4442, 1, 0, 0, 0, 4768, 4444, 1, 0, 0, 0, 4768, 4453, 1, 0, 0, 0, 4768, 4462, 1, 0, 0, 0, 4768, 4471, 1, 0, 0, 0, 4768, 4480, 1, 0, 0, 0, 4768, 4489, 1, 0, 0, 0, 4768, 4498, 1, 0, 0, 0, 4768, 4507, 1, 0, 0, 0, 4768, 4516, 1, 0, 0, 0, 4768, 4525, 1, 0, 0, 0, 4768, 4534, 1, 0, 0, 0, 4768, 4543, 1, 0, 0, 0, 4768, 4553, 1, 0, 0, 0, 4768, 4556, 1, 0, 0, 0, 4768, 4559, 1, 0, 0, 0, 4768, 4562, 1, 0, 0, 0, 4768, 4564, 1, 0, 0, 0, 4768, 4566, 1, 0, 0, 0, 4768, 4568, 1, 0, 0, 0, 4768, 4571, 1, 0, 0, 0, 4768, 4574, 1, 0, 0, 0, 4768, 4581, 1, 0, 0, 0, 4768, 4588, 1, 0, 0, 0, 4768, 4592, 1, 0, 0, 0, 4768, 4596, 1, 0, 0, 0, 4768, 4604, 1, 0, 0, 0, 4768, 4609, 1, 0, 0, 0, 4768, 4612, 1, 0, 0, 0, 4768, 4622, 1, 0, 0, 0, 4768, 4625, 1, 0, 0, 0, 4768, 4628, 1, 0, 0, 0, 4768, 4632, 1, 0, 0, 0, 4768, 4637, 1, 0, 0, 0, 4768, 4642, 1, 0, 0, 0, 4768, 4647, 1, 0, 0, 0, 4768, 4657, 1, 0, 0, 0, 4768, 4667, 1, 0, 0, 0, 4768, 4677, 1, 0, 0, 0, 4768, 4687, 1, 0, 0, 0, 4768, 4689, 1, 0, 0, 0, 4768, 4696, 1, 0, 0, 0, 4768, 4699, 1, 0, 0, 0, 4768, 4706, 1, 0, 0, 0, 4768, 4722, 1, 0, 0, 0, 4768, 4733, 1, 0, 0, 0, 4768, 4744, 1, 0, 0, 0, 4768, 4754, 1, 0, 0, 0, 4768, 4756, 1, 0, 0, 0, 4768, 4758, 1, 0, 0, 0, 4769, 541, 1, 0, 0, 0, 4770, 4771, 5, 71, 0, 0, 4771, 4776, 3, 546, 273, 0, 4772, 4773, 5, 280, 0, 0, 4773, 4775, 3, 546, 273, 0, 4774, 4772, 1, 0, 0, 0, 4775, 4778, 1, 0, 0, 0, 4776, 4774, 1, 0, 0, 0, 4776, 4777, 1, 0, 0, 0, 4777, 4784, 1, 0, 0, 0, 4778, 4776, 1, 0, 0, 0, 4779, 4782, 5, 284, 0, 0, 4780, 4783, 3, 684, 342, 0, 4781, 4783, 5, 503, 0, 0, 4782, 4780, 1, 0, 0, 0, 4782, 4781, 1, 0, 0, 0, 4783, 4785, 1, 0, 0, 0, 4784, 4779, 1, 0, 0, 0, 4784, 4785, 1, 0, 0, 0, 4785, 4792, 1, 0, 0, 0, 4786, 4789, 5, 284, 0, 0, 4787, 4790, 3, 684, 342, 0, 4788, 4790, 5, 503, 0, 0, 4789, 4787, 1, 0, 0, 0, 4789, 4788, 1, 0, 0, 0, 4790, 4792, 1, 0, 0, 0, 4791, 4770, 1, 0, 0, 0, 4791, 4786, 1, 0, 0, 0, 4792, 543, 1, 0, 0, 0, 4793, 4794, 7, 31, 0, 0, 4794, 545, 1, 0, 0, 0, 4795, 4796, 5, 423, 0, 0, 4796, 4797, 7, 32, 0, 0, 4797, 4802, 5, 499, 0, 0, 4798, 4799, 5, 503, 0, 0, 4799, 4800, 7, 32, 0, 0, 4800, 4802, 5, 499, 0, 0, 4801, 4795, 1, 0, 0, 0, 4801, 4798, 1, 0, 0, 0, 4802, 547, 1, 0, 0, 0, 4803, 4804, 5, 499, 0, 0, 4804, 4805, 5, 472, 0, 0, 4805, 4806, 3, 550, 275, 0, 4806, 549, 1, 0, 0, 0, 4807, 4812, 5, 499, 0, 0, 4808, 4812, 5, 501, 0, 0, 4809, 4812, 3, 692, 346, 0, 4810, 4812, 5, 283, 0, 0, 4811, 4807, 1, 0, 0, 0, 4811, 4808, 1, 0, 0, 0, 4811, 4809, 1, 0, 0, 0, 4811, 4810, 1, 0, 0, 0, 4812, 551, 1, 0, 0, 0, 4813, 4814, 5, 65, 0, 0, 4814, 4815, 5, 23, 0, 0, 4815, 4928, 3, 684, 342, 0, 4816, 4817, 5, 65, 0, 0, 4817, 4818, 5, 27, 0, 0, 4818, 4928, 3, 684, 342, 0, 4819, 4820, 5, 65, 0, 0, 4820, 4821, 5, 30, 0, 0, 4821, 4928, 3, 684, 342, 0, 4822, 4823, 5, 65, 0, 0, 4823, 4824, 5, 31, 0, 0, 4824, 4928, 3, 684, 342, 0, 4825, 4826, 5, 65, 0, 0, 4826, 4827, 5, 32, 0, 0, 4827, 4928, 3, 684, 342, 0, 4828, 4829, 5, 65, 0, 0, 4829, 4830, 5, 33, 0, 0, 4830, 4928, 3, 684, 342, 0, 4831, 4832, 5, 65, 0, 0, 4832, 4833, 5, 34, 0, 0, 4833, 4928, 3, 684, 342, 0, 4834, 4835, 5, 65, 0, 0, 4835, 4836, 5, 35, 0, 0, 4836, 4928, 3, 684, 342, 0, 4837, 4838, 5, 65, 0, 0, 4838, 4839, 5, 28, 0, 0, 4839, 4928, 3, 684, 342, 0, 4840, 4841, 5, 65, 0, 0, 4841, 4842, 5, 37, 0, 0, 4842, 4928, 3, 684, 342, 0, 4843, 4844, 5, 65, 0, 0, 4844, 4845, 5, 113, 0, 0, 4845, 4846, 5, 114, 0, 0, 4846, 4928, 3, 684, 342, 0, 4847, 4848, 5, 65, 0, 0, 4848, 4849, 5, 29, 0, 0, 4849, 4852, 5, 503, 0, 0, 4850, 4851, 5, 137, 0, 0, 4851, 4853, 5, 84, 0, 0, 4852, 4850, 1, 0, 0, 0, 4852, 4853, 1, 0, 0, 0, 4853, 4928, 1, 0, 0, 0, 4854, 4855, 5, 65, 0, 0, 4855, 4856, 5, 29, 0, 0, 4856, 4857, 5, 431, 0, 0, 4857, 4928, 3, 684, 342, 0, 4858, 4859, 5, 65, 0, 0, 4859, 4860, 5, 443, 0, 0, 4860, 4861, 5, 431, 0, 0, 4861, 4928, 5, 499, 0, 0, 4862, 4863, 5, 65, 0, 0, 4863, 4864, 5, 438, 0, 0, 4864, 4865, 5, 443, 0, 0, 4865, 4928, 5, 499, 0, 0, 4866, 4867, 5, 65, 0, 0, 4867, 4868, 5, 309, 0, 0, 4868, 4869, 5, 332, 0, 0, 4869, 4928, 3, 684, 342, 0, 4870, 4871, 5, 65, 0, 0, 4871, 4872, 5, 309, 0, 0, 4872, 4873, 5, 307, 0, 0, 4873, 4928, 3, 684, 342, 0, 4874, 4875, 5, 65, 0, 0, 4875, 4876, 5, 26, 0, 0, 4876, 4877, 5, 23, 0, 0, 4877, 4928, 3, 684, 342, 0, 4878, 4879, 5, 65, 0, 0, 4879, 4882, 5, 362, 0, 0, 4880, 4883, 3, 684, 342, 0, 4881, 4883, 5, 503, 0, 0, 4882, 4880, 1, 0, 0, 0, 4882, 4881, 1, 0, 0, 0, 4882, 4883, 1, 0, 0, 0, 4883, 4928, 1, 0, 0, 0, 4884, 4885, 5, 65, 0, 0, 4885, 4886, 5, 209, 0, 0, 4886, 4887, 5, 92, 0, 0, 4887, 4888, 7, 1, 0, 0, 4888, 4891, 3, 684, 342, 0, 4889, 4890, 5, 184, 0, 0, 4890, 4892, 5, 503, 0, 0, 4891, 4889, 1, 0, 0, 0, 4891, 4892, 1, 0, 0, 0, 4892, 4928, 1, 0, 0, 0, 4893, 4894, 5, 65, 0, 0, 4894, 4895, 5, 395, 0, 0, 4895, 4896, 5, 484, 0, 0, 4896, 4928, 3, 558, 279, 0, 4897, 4898, 5, 65, 0, 0, 4898, 4899, 5, 425, 0, 0, 4899, 4900, 5, 426, 0, 0, 4900, 4901, 5, 307, 0, 0, 4901, 4928, 3, 684, 342, 0, 4902, 4903, 5, 65, 0, 0, 4903, 4904, 5, 344, 0, 0, 4904, 4905, 5, 343, 0, 0, 4905, 4928, 3, 684, 342, 0, 4906, 4907, 5, 65, 0, 0, 4907, 4928, 5, 428, 0, 0, 4908, 4909, 5, 65, 0, 0, 4909, 4910, 5, 378, 0, 0, 4910, 4911, 5, 70, 0, 0, 4911, 4912, 5, 33, 0, 0, 4912, 4913, 3, 684, 342, 0, 4913, 4914, 5, 184, 0, 0, 4914, 4915, 3, 686, 343, 0, 4915, 4928, 1, 0, 0, 0, 4916, 4917, 5, 65, 0, 0, 4917, 4918, 5, 378, 0, 0, 4918, 4919, 5, 70, 0, 0, 4919, 4920, 5, 34, 0, 0, 4920, 4921, 3, 684, 342, 0, 4921, 4922, 5, 184, 0, 0, 4922, 4923, 3, 686, 343, 0, 4923, 4928, 1, 0, 0, 0, 4924, 4925, 5, 65, 0, 0, 4925, 4926, 5, 378, 0, 0, 4926, 4928, 3, 686, 343, 0, 4927, 4813, 1, 0, 0, 0, 4927, 4816, 1, 0, 0, 0, 4927, 4819, 1, 0, 0, 0, 4927, 4822, 1, 0, 0, 0, 4927, 4825, 1, 0, 0, 0, 4927, 4828, 1, 0, 0, 0, 4927, 4831, 1, 0, 0, 0, 4927, 4834, 1, 0, 0, 0, 4927, 4837, 1, 0, 0, 0, 4927, 4840, 1, 0, 0, 0, 4927, 4843, 1, 0, 0, 0, 4927, 4847, 1, 0, 0, 0, 4927, 4854, 1, 0, 0, 0, 4927, 4858, 1, 0, 0, 0, 4927, 4862, 1, 0, 0, 0, 4927, 4866, 1, 0, 0, 0, 4927, 4870, 1, 0, 0, 0, 4927, 4874, 1, 0, 0, 0, 4927, 4878, 1, 0, 0, 0, 4927, 4884, 1, 0, 0, 0, 4927, 4893, 1, 0, 0, 0, 4927, 4897, 1, 0, 0, 0, 4927, 4902, 1, 0, 0, 0, 4927, 4906, 1, 0, 0, 0, 4927, 4908, 1, 0, 0, 0, 4927, 4916, 1, 0, 0, 0, 4927, 4924, 1, 0, 0, 0, 4928, 553, 1, 0, 0, 0, 4929, 4931, 5, 69, 0, 0, 4930, 4932, 7, 33, 0, 0, 4931, 4930, 1, 0, 0, 0, 4931, 4932, 1, 0, 0, 0, 4932, 4933, 1, 0, 0, 0, 4933, 4934, 3, 566, 283, 0, 4934, 4935, 5, 70, 0, 0, 4935, 4936, 5, 395, 0, 0, 4936, 4937, 5, 484, 0, 0, 4937, 4942, 3, 558, 279, 0, 4938, 4940, 5, 75, 0, 0, 4939, 4938, 1, 0, 0, 0, 4939, 4940, 1, 0, 0, 0, 4940, 4941, 1, 0, 0, 0, 4941, 4943, 5, 503, 0, 0, 4942, 4939, 1, 0, 0, 0, 4942, 4943, 1, 0, 0, 0, 4943, 4947, 1, 0, 0, 0, 4944, 4946, 3, 556, 278, 0, 4945, 4944, 1, 0, 0, 0, 4946, 4949, 1, 0, 0, 0, 4947, 4945, 1, 0, 0, 0, 4947, 4948, 1, 0, 0, 0, 4948, 4952, 1, 0, 0, 0, 4949, 4947, 1, 0, 0, 0, 4950, 4951, 5, 71, 0, 0, 4951, 4953, 3, 646, 323, 0, 4952, 4950, 1, 0, 0, 0, 4952, 4953, 1, 0, 0, 0, 4953, 4960, 1, 0, 0, 0, 4954, 4955, 5, 8, 0, 0, 4955, 4958, 3, 594, 297, 0, 4956, 4957, 5, 72, 0, 0, 4957, 4959, 3, 646, 323, 0, 4958, 4956, 1, 0, 0, 0, 4958, 4959, 1, 0, 0, 0, 4959, 4961, 1, 0, 0, 0, 4960, 4954, 1, 0, 0, 0, 4960, 4961, 1, 0, 0, 0, 4961, 4964, 1, 0, 0, 0, 4962, 4963, 5, 9, 0, 0, 4963, 4965, 3, 590, 295, 0, 4964, 4962, 1, 0, 0, 0, 4964, 4965, 1, 0, 0, 0, 4965, 4968, 1, 0, 0, 0, 4966, 4967, 5, 74, 0, 0, 4967, 4969, 5, 501, 0, 0, 4968, 4966, 1, 0, 0, 0, 4968, 4969, 1, 0, 0, 0, 4969, 4972, 1, 0, 0, 0, 4970, 4971, 5, 73, 0, 0, 4971, 4973, 5, 501, 0, 0, 4972, 4970, 1, 0, 0, 0, 4972, 4973, 1, 0, 0, 0, 4973, 555, 1, 0, 0, 0, 4974, 4976, 3, 580, 290, 0, 4975, 4974, 1, 0, 0, 0, 4975, 4976, 1, 0, 0, 0, 4976, 4977, 1, 0, 0, 0, 4977, 4978, 5, 85, 0, 0, 4978, 4979, 5, 395, 0, 0, 4979, 4980, 5, 484, 0, 0, 4980, 4985, 3, 558, 279, 0, 4981, 4983, 5, 75, 0, 0, 4982, 4981, 1, 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 4984, 1, 0, 0, 0, 4984, 4986, 5, 503, 0, 0, 4985, 4982, 1, 0, 0, 0, 4985, 4986, 1, 0, 0, 0, 4986, 4989, 1, 0, 0, 0, 4987, 4988, 5, 92, 0, 0, 4988, 4990, 3, 646, 323, 0, 4989, 4987, 1, 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990, 557, 1, 0, 0, 0, 4991, 4992, 7, 34, 0, 0, 4992, 559, 1, 0, 0, 0, 4993, 5001, 3, 562, 281, 0, 4994, 4996, 5, 123, 0, 0, 4995, 4997, 5, 84, 0, 0, 4996, 4995, 1, 0, 0, 0, 4996, 4997, 1, 0, 0, 0, 4997, 4998, 1, 0, 0, 0, 4998, 5000, 3, 562, 281, 0, 4999, 4994, 1, 0, 0, 0, 5000, 5003, 1, 0, 0, 0, 5001, 4999, 1, 0, 0, 0, 5001, 5002, 1, 0, 0, 0, 5002, 561, 1, 0, 0, 0, 5003, 5001, 1, 0, 0, 0, 5004, 5006, 3, 564, 282, 0, 5005, 5007, 3, 572, 286, 0, 5006, 5005, 1, 0, 0, 0, 5006, 5007, 1, 0, 0, 0, 5007, 5009, 1, 0, 0, 0, 5008, 5010, 3, 582, 291, 0, 5009, 5008, 1, 0, 0, 0, 5009, 5010, 1, 0, 0, 0, 5010, 5012, 1, 0, 0, 0, 5011, 5013, 3, 584, 292, 0, 5012, 5011, 1, 0, 0, 0, 5012, 5013, 1, 0, 0, 0, 5013, 5015, 1, 0, 0, 0, 5014, 5016, 3, 586, 293, 0, 5015, 5014, 1, 0, 0, 0, 5015, 5016, 1, 0, 0, 0, 5016, 5018, 1, 0, 0, 0, 5017, 5019, 3, 588, 294, 0, 5018, 5017, 1, 0, 0, 0, 5018, 5019, 1, 0, 0, 0, 5019, 5021, 1, 0, 0, 0, 5020, 5022, 3, 596, 298, 0, 5021, 5020, 1, 0, 0, 0, 5021, 5022, 1, 0, 0, 0, 5022, 5041, 1, 0, 0, 0, 5023, 5025, 3, 572, 286, 0, 5024, 5026, 3, 582, 291, 0, 5025, 5024, 1, 0, 0, 0, 5025, 5026, 1, 0, 0, 0, 5026, 5028, 1, 0, 0, 0, 5027, 5029, 3, 584, 292, 0, 5028, 5027, 1, 0, 0, 0, 5028, 5029, 1, 0, 0, 0, 5029, 5031, 1, 0, 0, 0, 5030, 5032, 3, 586, 293, 0, 5031, 5030, 1, 0, 0, 0, 5031, 5032, 1, 0, 0, 0, 5032, 5033, 1, 0, 0, 0, 5033, 5035, 3, 564, 282, 0, 5034, 5036, 3, 588, 294, 0, 5035, 5034, 1, 0, 0, 0, 5035, 5036, 1, 0, 0, 0, 5036, 5038, 1, 0, 0, 0, 5037, 5039, 3, 596, 298, 0, 5038, 5037, 1, 0, 0, 0, 5038, 5039, 1, 0, 0, 0, 5039, 5041, 1, 0, 0, 0, 5040, 5004, 1, 0, 0, 0, 5040, 5023, 1, 0, 0, 0, 5041, 563, 1, 0, 0, 0, 5042, 5044, 5, 69, 0, 0, 5043, 5045, 7, 33, 0, 0, 5044, 5043, 1, 0, 0, 0, 5044, 5045, 1, 0, 0, 0, 5045, 5046, 1, 0, 0, 0, 5046, 5047, 3, 566, 283, 0, 5047, 565, 1, 0, 0, 0, 5048, 5058, 5, 477, 0, 0, 5049, 5054, 3, 568, 284, 0, 5050, 5051, 5, 483, 0, 0, 5051, 5053, 3, 568, 284, 0, 5052, 5050, 1, 0, 0, 0, 5053, 5056, 1, 0, 0, 0, 5054, 5052, 1, 0, 0, 0, 5054, 5055, 1, 0, 0, 0, 5055, 5058, 1, 0, 0, 0, 5056, 5054, 1, 0, 0, 0, 5057, 5048, 1, 0, 0, 0, 5057, 5049, 1, 0, 0, 0, 5058, 567, 1, 0, 0, 0, 5059, 5062, 3, 646, 323, 0, 5060, 5061, 5, 75, 0, 0, 5061, 5063, 3, 570, 285, 0, 5062, 5060, 1, 0, 0, 0, 5062, 5063, 1, 0, 0, 0, 5063, 5070, 1, 0, 0, 0, 5064, 5067, 3, 672, 336, 0, 5065, 5066, 5, 75, 0, 0, 5066, 5068, 3, 570, 285, 0, 5067, 5065, 1, 0, 0, 0, 5067, 5068, 1, 0, 0, 0, 5068, 5070, 1, 0, 0, 0, 5069, 5059, 1, 0, 0, 0, 5069, 5064, 1, 0, 0, 0, 5070, 569, 1, 0, 0, 0, 5071, 5074, 5, 503, 0, 0, 5072, 5074, 3, 706, 353, 0, 5073, 5071, 1, 0, 0, 0, 5073, 5072, 1, 0, 0, 0, 5074, 571, 1, 0, 0, 0, 5075, 5076, 5, 70, 0, 0, 5076, 5080, 3, 574, 287, 0, 5077, 5079, 3, 576, 288, 0, 5078, 5077, 1, 0, 0, 0, 5079, 5082, 1, 0, 0, 0, 5080, 5078, 1, 0, 0, 0, 5080, 5081, 1, 0, 0, 0, 5081, 573, 1, 0, 0, 0, 5082, 5080, 1, 0, 0, 0, 5083, 5088, 3, 684, 342, 0, 5084, 5086, 5, 75, 0, 0, 5085, 5084, 1, 0, 0, 0, 5085, 5086, 1, 0, 0, 0, 5086, 5087, 1, 0, 0, 0, 5087, 5089, 5, 503, 0, 0, 5088, 5085, 1, 0, 0, 0, 5088, 5089, 1, 0, 0, 0, 5089, 5100, 1, 0, 0, 0, 5090, 5091, 5, 485, 0, 0, 5091, 5092, 3, 560, 280, 0, 5092, 5097, 5, 486, 0, 0, 5093, 5095, 5, 75, 0, 0, 5094, 5093, 1, 0, 0, 0, 5094, 5095, 1, 0, 0, 0, 5095, 5096, 1, 0, 0, 0, 5096, 5098, 5, 503, 0, 0, 5097, 5094, 1, 0, 0, 0, 5097, 5098, 1, 0, 0, 0, 5098, 5100, 1, 0, 0, 0, 5099, 5083, 1, 0, 0, 0, 5099, 5090, 1, 0, 0, 0, 5100, 575, 1, 0, 0, 0, 5101, 5103, 3, 580, 290, 0, 5102, 5101, 1, 0, 0, 0, 5102, 5103, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5105, 5, 85, 0, 0, 5105, 5108, 3, 574, 287, 0, 5106, 5107, 5, 92, 0, 0, 5107, 5109, 3, 646, 323, 0, 5108, 5106, 1, 0, 0, 0, 5108, 5109, 1, 0, 0, 0, 5109, 5122, 1, 0, 0, 0, 5110, 5112, 3, 580, 290, 0, 5111, 5110, 1, 0, 0, 0, 5111, 5112, 1, 0, 0, 0, 5112, 5113, 1, 0, 0, 0, 5113, 5114, 5, 85, 0, 0, 5114, 5119, 3, 578, 289, 0, 5115, 5117, 5, 75, 0, 0, 5116, 5115, 1, 0, 0, 0, 5116, 5117, 1, 0, 0, 0, 5117, 5118, 1, 0, 0, 0, 5118, 5120, 5, 503, 0, 0, 5119, 5116, 1, 0, 0, 0, 5119, 5120, 1, 0, 0, 0, 5120, 5122, 1, 0, 0, 0, 5121, 5102, 1, 0, 0, 0, 5121, 5111, 1, 0, 0, 0, 5122, 577, 1, 0, 0, 0, 5123, 5124, 5, 503, 0, 0, 5124, 5125, 5, 478, 0, 0, 5125, 5126, 3, 684, 342, 0, 5126, 5127, 5, 478, 0, 0, 5127, 5128, 3, 684, 342, 0, 5128, 5134, 1, 0, 0, 0, 5129, 5130, 3, 684, 342, 0, 5130, 5131, 5, 478, 0, 0, 5131, 5132, 3, 684, 342, 0, 5132, 5134, 1, 0, 0, 0, 5133, 5123, 1, 0, 0, 0, 5133, 5129, 1, 0, 0, 0, 5134, 579, 1, 0, 0, 0, 5135, 5137, 5, 86, 0, 0, 5136, 5138, 5, 89, 0, 0, 5137, 5136, 1, 0, 0, 0, 5137, 5138, 1, 0, 0, 0, 5138, 5150, 1, 0, 0, 0, 5139, 5141, 5, 87, 0, 0, 5140, 5142, 5, 89, 0, 0, 5141, 5140, 1, 0, 0, 0, 5141, 5142, 1, 0, 0, 0, 5142, 5150, 1, 0, 0, 0, 5143, 5150, 5, 88, 0, 0, 5144, 5146, 5, 90, 0, 0, 5145, 5147, 5, 89, 0, 0, 5146, 5145, 1, 0, 0, 0, 5146, 5147, 1, 0, 0, 0, 5147, 5150, 1, 0, 0, 0, 5148, 5150, 5, 91, 0, 0, 5149, 5135, 1, 0, 0, 0, 5149, 5139, 1, 0, 0, 0, 5149, 5143, 1, 0, 0, 0, 5149, 5144, 1, 0, 0, 0, 5149, 5148, 1, 0, 0, 0, 5150, 581, 1, 0, 0, 0, 5151, 5152, 5, 71, 0, 0, 5152, 5153, 3, 646, 323, 0, 5153, 583, 1, 0, 0, 0, 5154, 5155, 5, 8, 0, 0, 5155, 5156, 3, 682, 341, 0, 5156, 585, 1, 0, 0, 0, 5157, 5158, 5, 72, 0, 0, 5158, 5159, 3, 646, 323, 0, 5159, 587, 1, 0, 0, 0, 5160, 5161, 5, 9, 0, 0, 5161, 5162, 3, 590, 295, 0, 5162, 589, 1, 0, 0, 0, 5163, 5168, 3, 592, 296, 0, 5164, 5165, 5, 483, 0, 0, 5165, 5167, 3, 592, 296, 0, 5166, 5164, 1, 0, 0, 0, 5167, 5170, 1, 0, 0, 0, 5168, 5166, 1, 0, 0, 0, 5168, 5169, 1, 0, 0, 0, 5169, 591, 1, 0, 0, 0, 5170, 5168, 1, 0, 0, 0, 5171, 5173, 3, 646, 323, 0, 5172, 5174, 7, 6, 0, 0, 5173, 5172, 1, 0, 0, 0, 5173, 5174, 1, 0, 0, 0, 5174, 593, 1, 0, 0, 0, 5175, 5180, 3, 646, 323, 0, 5176, 5177, 5, 483, 0, 0, 5177, 5179, 3, 646, 323, 0, 5178, 5176, 1, 0, 0, 0, 5179, 5182, 1, 0, 0, 0, 5180, 5178, 1, 0, 0, 0, 5180, 5181, 1, 0, 0, 0, 5181, 595, 1, 0, 0, 0, 5182, 5180, 1, 0, 0, 0, 5183, 5184, 5, 74, 0, 0, 5184, 5187, 5, 501, 0, 0, 5185, 5186, 5, 73, 0, 0, 5186, 5188, 5, 501, 0, 0, 5187, 5185, 1, 0, 0, 0, 5187, 5188, 1, 0, 0, 0, 5188, 5196, 1, 0, 0, 0, 5189, 5190, 5, 73, 0, 0, 5190, 5193, 5, 501, 0, 0, 5191, 5192, 5, 74, 0, 0, 5192, 5194, 5, 501, 0, 0, 5193, 5191, 1, 0, 0, 0, 5193, 5194, 1, 0, 0, 0, 5194, 5196, 1, 0, 0, 0, 5195, 5183, 1, 0, 0, 0, 5195, 5189, 1, 0, 0, 0, 5196, 597, 1, 0, 0, 0, 5197, 5214, 3, 602, 301, 0, 5198, 5214, 3, 604, 302, 0, 5199, 5214, 3, 606, 303, 0, 5200, 5214, 3, 608, 304, 0, 5201, 5214, 3, 610, 305, 0, 5202, 5214, 3, 612, 306, 0, 5203, 5214, 3, 614, 307, 0, 5204, 5214, 3, 616, 308, 0, 5205, 5214, 3, 600, 300, 0, 5206, 5214, 3, 622, 311, 0, 5207, 5214, 3, 628, 314, 0, 5208, 5214, 3, 630, 315, 0, 5209, 5214, 3, 644, 322, 0, 5210, 5214, 3, 632, 316, 0, 5211, 5214, 3, 636, 318, 0, 5212, 5214, 3, 642, 321, 0, 5213, 5197, 1, 0, 0, 0, 5213, 5198, 1, 0, 0, 0, 5213, 5199, 1, 0, 0, 0, 5213, 5200, 1, 0, 0, 0, 5213, 5201, 1, 0, 0, 0, 5213, 5202, 1, 0, 0, 0, 5213, 5203, 1, 0, 0, 0, 5213, 5204, 1, 0, 0, 0, 5213, 5205, 1, 0, 0, 0, 5213, 5206, 1, 0, 0, 0, 5213, 5207, 1, 0, 0, 0, 5213, 5208, 1, 0, 0, 0, 5213, 5209, 1, 0, 0, 0, 5213, 5210, 1, 0, 0, 0, 5213, 5211, 1, 0, 0, 0, 5213, 5212, 1, 0, 0, 0, 5214, 599, 1, 0, 0, 0, 5215, 5216, 5, 156, 0, 0, 5216, 5217, 5, 499, 0, 0, 5217, 601, 1, 0, 0, 0, 5218, 5219, 5, 55, 0, 0, 5219, 5220, 5, 411, 0, 0, 5220, 5221, 5, 58, 0, 0, 5221, 5224, 5, 499, 0, 0, 5222, 5223, 5, 60, 0, 0, 5223, 5225, 5, 499, 0, 0, 5224, 5222, 1, 0, 0, 0, 5224, 5225, 1, 0, 0, 0, 5225, 5226, 1, 0, 0, 0, 5226, 5227, 5, 61, 0, 0, 5227, 5242, 5, 499, 0, 0, 5228, 5229, 5, 55, 0, 0, 5229, 5230, 5, 57, 0, 0, 5230, 5242, 5, 499, 0, 0, 5231, 5232, 5, 55, 0, 0, 5232, 5233, 5, 59, 0, 0, 5233, 5234, 5, 62, 0, 0, 5234, 5235, 5, 499, 0, 0, 5235, 5236, 5, 63, 0, 0, 5236, 5239, 5, 501, 0, 0, 5237, 5238, 5, 61, 0, 0, 5238, 5240, 5, 499, 0, 0, 5239, 5237, 1, 0, 0, 0, 5239, 5240, 1, 0, 0, 0, 5240, 5242, 1, 0, 0, 0, 5241, 5218, 1, 0, 0, 0, 5241, 5228, 1, 0, 0, 0, 5241, 5231, 1, 0, 0, 0, 5242, 603, 1, 0, 0, 0, 5243, 5244, 5, 56, 0, 0, 5244, 605, 1, 0, 0, 0, 5245, 5262, 5, 383, 0, 0, 5246, 5247, 5, 384, 0, 0, 5247, 5249, 5, 395, 0, 0, 5248, 5250, 5, 90, 0, 0, 5249, 5248, 1, 0, 0, 0, 5249, 5250, 1, 0, 0, 0, 5250, 5252, 1, 0, 0, 0, 5251, 5253, 5, 190, 0, 0, 5252, 5251, 1, 0, 0, 0, 5252, 5253, 1, 0, 0, 0, 5253, 5255, 1, 0, 0, 0, 5254, 5256, 5, 396, 0, 0, 5255, 5254, 1, 0, 0, 0, 5255, 5256, 1, 0, 0, 0, 5256, 5258, 1, 0, 0, 0, 5257, 5259, 5, 397, 0, 0, 5258, 5257, 1, 0, 0, 0, 5258, 5259, 1, 0, 0, 0, 5259, 5262, 1, 0, 0, 0, 5260, 5262, 5, 384, 0, 0, 5261, 5245, 1, 0, 0, 0, 5261, 5246, 1, 0, 0, 0, 5261, 5260, 1, 0, 0, 0, 5262, 607, 1, 0, 0, 0, 5263, 5264, 5, 385, 0, 0, 5264, 609, 1, 0, 0, 0, 5265, 5266, 5, 386, 0, 0, 5266, 611, 1, 0, 0, 0, 5267, 5268, 5, 387, 0, 0, 5268, 5269, 5, 388, 0, 0, 5269, 5270, 5, 499, 0, 0, 5270, 613, 1, 0, 0, 0, 5271, 5272, 5, 387, 0, 0, 5272, 5273, 5, 59, 0, 0, 5273, 5274, 5, 499, 0, 0, 5274, 615, 1, 0, 0, 0, 5275, 5277, 5, 389, 0, 0, 5276, 5278, 3, 618, 309, 0, 5277, 5276, 1, 0, 0, 0, 5277, 5278, 1, 0, 0, 0, 5278, 5281, 1, 0, 0, 0, 5279, 5280, 5, 418, 0, 0, 5280, 5282, 3, 620, 310, 0, 5281, 5279, 1, 0, 0, 0, 5281, 5282, 1, 0, 0, 0, 5282, 5287, 1, 0, 0, 0, 5283, 5284, 5, 64, 0, 0, 5284, 5285, 5, 389, 0, 0, 5285, 5287, 5, 390, 0, 0, 5286, 5275, 1, 0, 0, 0, 5286, 5283, 1, 0, 0, 0, 5287, 617, 1, 0, 0, 0, 5288, 5289, 3, 684, 342, 0, 5289, 5290, 5, 484, 0, 0, 5290, 5291, 5, 477, 0, 0, 5291, 5295, 1, 0, 0, 0, 5292, 5295, 3, 684, 342, 0, 5293, 5295, 5, 477, 0, 0, 5294, 5288, 1, 0, 0, 0, 5294, 5292, 1, 0, 0, 0, 5294, 5293, 1, 0, 0, 0, 5295, 619, 1, 0, 0, 0, 5296, 5297, 7, 35, 0, 0, 5297, 621, 1, 0, 0, 0, 5298, 5299, 5, 66, 0, 0, 5299, 5303, 3, 624, 312, 0, 5300, 5301, 5, 66, 0, 0, 5301, 5303, 5, 84, 0, 0, 5302, 5298, 1, 0, 0, 0, 5302, 5300, 1, 0, 0, 0, 5303, 623, 1, 0, 0, 0, 5304, 5309, 3, 626, 313, 0, 5305, 5306, 5, 483, 0, 0, 5306, 5308, 3, 626, 313, 0, 5307, 5305, 1, 0, 0, 0, 5308, 5311, 1, 0, 0, 0, 5309, 5307, 1, 0, 0, 0, 5309, 5310, 1, 0, 0, 0, 5310, 625, 1, 0, 0, 0, 5311, 5309, 1, 0, 0, 0, 5312, 5313, 7, 36, 0, 0, 5313, 627, 1, 0, 0, 0, 5314, 5315, 5, 67, 0, 0, 5315, 5316, 5, 331, 0, 0, 5316, 629, 1, 0, 0, 0, 5317, 5318, 5, 68, 0, 0, 5318, 5319, 5, 499, 0, 0, 5319, 631, 1, 0, 0, 0, 5320, 5321, 5, 419, 0, 0, 5321, 5322, 5, 55, 0, 0, 5322, 5323, 5, 503, 0, 0, 5323, 5324, 5, 499, 0, 0, 5324, 5325, 5, 75, 0, 0, 5325, 5380, 5, 503, 0, 0, 5326, 5327, 5, 419, 0, 0, 5327, 5328, 5, 56, 0, 0, 5328, 5380, 5, 503, 0, 0, 5329, 5330, 5, 419, 0, 0, 5330, 5380, 5, 376, 0, 0, 5331, 5332, 5, 419, 0, 0, 5332, 5333, 5, 503, 0, 0, 5333, 5334, 5, 64, 0, 0, 5334, 5380, 5, 503, 0, 0, 5335, 5336, 5, 419, 0, 0, 5336, 5337, 5, 503, 0, 0, 5337, 5338, 5, 65, 0, 0, 5338, 5380, 5, 503, 0, 0, 5339, 5340, 5, 419, 0, 0, 5340, 5341, 5, 503, 0, 0, 5341, 5342, 5, 353, 0, 0, 5342, 5343, 5, 354, 0, 0, 5343, 5344, 5, 349, 0, 0, 5344, 5357, 3, 686, 343, 0, 5345, 5346, 5, 356, 0, 0, 5346, 5347, 5, 485, 0, 0, 5347, 5352, 3, 686, 343, 0, 5348, 5349, 5, 483, 0, 0, 5349, 5351, 3, 686, 343, 0, 5350, 5348, 1, 0, 0, 0, 5351, 5354, 1, 0, 0, 0, 5352, 5350, 1, 0, 0, 0, 5352, 5353, 1, 0, 0, 0, 5353, 5355, 1, 0, 0, 0, 5354, 5352, 1, 0, 0, 0, 5355, 5356, 5, 486, 0, 0, 5356, 5358, 1, 0, 0, 0, 5357, 5345, 1, 0, 0, 0, 5357, 5358, 1, 0, 0, 0, 5358, 5371, 1, 0, 0, 0, 5359, 5360, 5, 357, 0, 0, 5360, 5361, 5, 485, 0, 0, 5361, 5366, 3, 686, 343, 0, 5362, 5363, 5, 483, 0, 0, 5363, 5365, 3, 686, 343, 0, 5364, 5362, 1, 0, 0, 0, 5365, 5368, 1, 0, 0, 0, 5366, 5364, 1, 0, 0, 0, 5366, 5367, 1, 0, 0, 0, 5367, 5369, 1, 0, 0, 0, 5368, 5366, 1, 0, 0, 0, 5369, 5370, 5, 486, 0, 0, 5370, 5372, 1, 0, 0, 0, 5371, 5359, 1, 0, 0, 0, 5371, 5372, 1, 0, 0, 0, 5372, 5374, 1, 0, 0, 0, 5373, 5375, 5, 355, 0, 0, 5374, 5373, 1, 0, 0, 0, 5374, 5375, 1, 0, 0, 0, 5375, 5380, 1, 0, 0, 0, 5376, 5377, 5, 419, 0, 0, 5377, 5378, 5, 503, 0, 0, 5378, 5380, 3, 634, 317, 0, 5379, 5320, 1, 0, 0, 0, 5379, 5326, 1, 0, 0, 0, 5379, 5329, 1, 0, 0, 0, 5379, 5331, 1, 0, 0, 0, 5379, 5335, 1, 0, 0, 0, 5379, 5339, 1, 0, 0, 0, 5379, 5376, 1, 0, 0, 0, 5380, 633, 1, 0, 0, 0, 5381, 5383, 8, 37, 0, 0, 5382, 5381, 1, 0, 0, 0, 5383, 5384, 1, 0, 0, 0, 5384, 5382, 1, 0, 0, 0, 5384, 5385, 1, 0, 0, 0, 5385, 635, 1, 0, 0, 0, 5386, 5387, 5, 348, 0, 0, 5387, 5388, 5, 70, 0, 0, 5388, 5389, 3, 686, 343, 0, 5389, 5390, 5, 345, 0, 0, 5390, 5391, 7, 25, 0, 0, 5391, 5392, 5, 349, 0, 0, 5392, 5393, 3, 684, 342, 0, 5393, 5394, 5, 346, 0, 0, 5394, 5395, 5, 485, 0, 0, 5395, 5400, 3, 638, 319, 0, 5396, 5397, 5, 483, 0, 0, 5397, 5399, 3, 638, 319, 0, 5398, 5396, 1, 0, 0, 0, 5399, 5402, 1, 0, 0, 0, 5400, 5398, 1, 0, 0, 0, 5400, 5401, 1, 0, 0, 0, 5401, 5403, 1, 0, 0, 0, 5402, 5400, 1, 0, 0, 0, 5403, 5416, 5, 486, 0, 0, 5404, 5405, 5, 351, 0, 0, 5405, 5406, 5, 485, 0, 0, 5406, 5411, 3, 640, 320, 0, 5407, 5408, 5, 483, 0, 0, 5408, 5410, 3, 640, 320, 0, 5409, 5407, 1, 0, 0, 0, 5410, 5413, 1, 0, 0, 0, 5411, 5409, 1, 0, 0, 0, 5411, 5412, 1, 0, 0, 0, 5412, 5414, 1, 0, 0, 0, 5413, 5411, 1, 0, 0, 0, 5414, 5415, 5, 486, 0, 0, 5415, 5417, 1, 0, 0, 0, 5416, 5404, 1, 0, 0, 0, 5416, 5417, 1, 0, 0, 0, 5417, 5420, 1, 0, 0, 0, 5418, 5419, 5, 350, 0, 0, 5419, 5421, 5, 501, 0, 0, 5420, 5418, 1, 0, 0, 0, 5420, 5421, 1, 0, 0, 0, 5421, 5424, 1, 0, 0, 0, 5422, 5423, 5, 74, 0, 0, 5423, 5425, 5, 501, 0, 0, 5424, 5422, 1, 0, 0, 0, 5424, 5425, 1, 0, 0, 0, 5425, 637, 1, 0, 0, 0, 5426, 5427, 3, 686, 343, 0, 5427, 5428, 5, 75, 0, 0, 5428, 5429, 3, 686, 343, 0, 5429, 639, 1, 0, 0, 0, 5430, 5431, 3, 686, 343, 0, 5431, 5432, 5, 411, 0, 0, 5432, 5433, 3, 686, 343, 0, 5433, 5434, 5, 92, 0, 0, 5434, 5435, 3, 686, 343, 0, 5435, 5441, 1, 0, 0, 0, 5436, 5437, 3, 686, 343, 0, 5437, 5438, 5, 411, 0, 0, 5438, 5439, 3, 686, 343, 0, 5439, 5441, 1, 0, 0, 0, 5440, 5430, 1, 0, 0, 0, 5440, 5436, 1, 0, 0, 0, 5441, 641, 1, 0, 0, 0, 5442, 5443, 5, 503, 0, 0, 5443, 643, 1, 0, 0, 0, 5444, 5445, 5, 377, 0, 0, 5445, 5446, 5, 378, 0, 0, 5446, 5447, 3, 686, 343, 0, 5447, 5448, 5, 75, 0, 0, 5448, 5449, 5, 487, 0, 0, 5449, 5450, 3, 368, 184, 0, 5450, 5451, 5, 488, 0, 0, 5451, 645, 1, 0, 0, 0, 5452, 5453, 3, 648, 324, 0, 5453, 647, 1, 0, 0, 0, 5454, 5459, 3, 650, 325, 0, 5455, 5456, 5, 281, 0, 0, 5456, 5458, 3, 650, 325, 0, 5457, 5455, 1, 0, 0, 0, 5458, 5461, 1, 0, 0, 0, 5459, 5457, 1, 0, 0, 0, 5459, 5460, 1, 0, 0, 0, 5460, 649, 1, 0, 0, 0, 5461, 5459, 1, 0, 0, 0, 5462, 5467, 3, 652, 326, 0, 5463, 5464, 5, 280, 0, 0, 5464, 5466, 3, 652, 326, 0, 5465, 5463, 1, 0, 0, 0, 5466, 5469, 1, 0, 0, 0, 5467, 5465, 1, 0, 0, 0, 5467, 5468, 1, 0, 0, 0, 5468, 651, 1, 0, 0, 0, 5469, 5467, 1, 0, 0, 0, 5470, 5472, 5, 282, 0, 0, 5471, 5470, 1, 0, 0, 0, 5471, 5472, 1, 0, 0, 0, 5472, 5473, 1, 0, 0, 0, 5473, 5474, 3, 654, 327, 0, 5474, 653, 1, 0, 0, 0, 5475, 5504, 3, 658, 329, 0, 5476, 5477, 3, 656, 328, 0, 5477, 5478, 3, 658, 329, 0, 5478, 5505, 1, 0, 0, 0, 5479, 5505, 5, 6, 0, 0, 5480, 5505, 5, 5, 0, 0, 5481, 5482, 5, 284, 0, 0, 5482, 5485, 5, 485, 0, 0, 5483, 5486, 3, 560, 280, 0, 5484, 5486, 3, 682, 341, 0, 5485, 5483, 1, 0, 0, 0, 5485, 5484, 1, 0, 0, 0, 5486, 5487, 1, 0, 0, 0, 5487, 5488, 5, 486, 0, 0, 5488, 5505, 1, 0, 0, 0, 5489, 5491, 5, 282, 0, 0, 5490, 5489, 1, 0, 0, 0, 5490, 5491, 1, 0, 0, 0, 5491, 5492, 1, 0, 0, 0, 5492, 5493, 5, 285, 0, 0, 5493, 5494, 3, 658, 329, 0, 5494, 5495, 5, 280, 0, 0, 5495, 5496, 3, 658, 329, 0, 5496, 5505, 1, 0, 0, 0, 5497, 5499, 5, 282, 0, 0, 5498, 5497, 1, 0, 0, 0, 5498, 5499, 1, 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5501, 5, 286, 0, 0, 5501, 5505, 3, 658, 329, 0, 5502, 5503, 5, 287, 0, 0, 5503, 5505, 3, 658, 329, 0, 5504, 5476, 1, 0, 0, 0, 5504, 5479, 1, 0, 0, 0, 5504, 5480, 1, 0, 0, 0, 5504, 5481, 1, 0, 0, 0, 5504, 5490, 1, 0, 0, 0, 5504, 5498, 1, 0, 0, 0, 5504, 5502, 1, 0, 0, 0, 5504, 5505, 1, 0, 0, 0, 5505, 655, 1, 0, 0, 0, 5506, 5507, 7, 38, 0, 0, 5507, 657, 1, 0, 0, 0, 5508, 5513, 3, 660, 330, 0, 5509, 5510, 7, 39, 0, 0, 5510, 5512, 3, 660, 330, 0, 5511, 5509, 1, 0, 0, 0, 5512, 5515, 1, 0, 0, 0, 5513, 5511, 1, 0, 0, 0, 5513, 5514, 1, 0, 0, 0, 5514, 659, 1, 0, 0, 0, 5515, 5513, 1, 0, 0, 0, 5516, 5521, 3, 662, 331, 0, 5517, 5518, 7, 40, 0, 0, 5518, 5520, 3, 662, 331, 0, 5519, 5517, 1, 0, 0, 0, 5520, 5523, 1, 0, 0, 0, 5521, 5519, 1, 0, 0, 0, 5521, 5522, 1, 0, 0, 0, 5522, 661, 1, 0, 0, 0, 5523, 5521, 1, 0, 0, 0, 5524, 5526, 7, 39, 0, 0, 5525, 5524, 1, 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5527, 1, 0, 0, 0, 5527, 5528, 3, 664, 332, 0, 5528, 663, 1, 0, 0, 0, 5529, 5530, 5, 485, 0, 0, 5530, 5531, 3, 646, 323, 0, 5531, 5532, 5, 486, 0, 0, 5532, 5550, 1, 0, 0, 0, 5533, 5534, 5, 485, 0, 0, 5534, 5535, 3, 560, 280, 0, 5535, 5536, 5, 486, 0, 0, 5536, 5550, 1, 0, 0, 0, 5537, 5538, 5, 288, 0, 0, 5538, 5539, 5, 485, 0, 0, 5539, 5540, 3, 560, 280, 0, 5540, 5541, 5, 486, 0, 0, 5541, 5550, 1, 0, 0, 0, 5542, 5550, 3, 666, 333, 0, 5543, 5550, 3, 668, 334, 0, 5544, 5550, 3, 292, 146, 0, 5545, 5550, 3, 284, 142, 0, 5546, 5550, 3, 672, 336, 0, 5547, 5550, 3, 674, 337, 0, 5548, 5550, 3, 680, 340, 0, 5549, 5529, 1, 0, 0, 0, 5549, 5533, 1, 0, 0, 0, 5549, 5537, 1, 0, 0, 0, 5549, 5542, 1, 0, 0, 0, 5549, 5543, 1, 0, 0, 0, 5549, 5544, 1, 0, 0, 0, 5549, 5545, 1, 0, 0, 0, 5549, 5546, 1, 0, 0, 0, 5549, 5547, 1, 0, 0, 0, 5549, 5548, 1, 0, 0, 0, 5550, 665, 1, 0, 0, 0, 5551, 5557, 5, 78, 0, 0, 5552, 5553, 5, 79, 0, 0, 5553, 5554, 3, 646, 323, 0, 5554, 5555, 5, 80, 0, 0, 5555, 5556, 3, 646, 323, 0, 5556, 5558, 1, 0, 0, 0, 5557, 5552, 1, 0, 0, 0, 5558, 5559, 1, 0, 0, 0, 5559, 5557, 1, 0, 0, 0, 5559, 5560, 1, 0, 0, 0, 5560, 5563, 1, 0, 0, 0, 5561, 5562, 5, 81, 0, 0, 5562, 5564, 3, 646, 323, 0, 5563, 5561, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, 0, 5564, 5565, 1, 0, 0, 0, 5565, 5566, 5, 82, 0, 0, 5566, 667, 1, 0, 0, 0, 5567, 5568, 5, 279, 0, 0, 5568, 5569, 5, 485, 0, 0, 5569, 5570, 3, 646, 323, 0, 5570, 5571, 5, 75, 0, 0, 5571, 5572, 3, 670, 335, 0, 5572, 5573, 5, 486, 0, 0, 5573, 669, 1, 0, 0, 0, 5574, 5575, 7, 41, 0, 0, 5575, 671, 1, 0, 0, 0, 5576, 5577, 7, 42, 0, 0, 5577, 5583, 5, 485, 0, 0, 5578, 5580, 5, 83, 0, 0, 5579, 5578, 1, 0, 0, 0, 5579, 5580, 1, 0, 0, 0, 5580, 5581, 1, 0, 0, 0, 5581, 5584, 3, 646, 323, 0, 5582, 5584, 5, 477, 0, 0, 5583, 5579, 1, 0, 0, 0, 5583, 5582, 1, 0, 0, 0, 5584, 5585, 1, 0, 0, 0, 5585, 5586, 5, 486, 0, 0, 5586, 673, 1, 0, 0, 0, 5587, 5588, 3, 676, 338, 0, 5588, 5590, 5, 485, 0, 0, 5589, 5591, 3, 678, 339, 0, 5590, 5589, 1, 0, 0, 0, 5590, 5591, 1, 0, 0, 0, 5591, 5592, 1, 0, 0, 0, 5592, 5593, 5, 486, 0, 0, 5593, 675, 1, 0, 0, 0, 5594, 5595, 7, 43, 0, 0, 5595, 677, 1, 0, 0, 0, 5596, 5601, 3, 646, 323, 0, 5597, 5598, 5, 483, 0, 0, 5598, 5600, 3, 646, 323, 0, 5599, 5597, 1, 0, 0, 0, 5600, 5603, 1, 0, 0, 0, 5601, 5599, 1, 0, 0, 0, 5601, 5602, 1, 0, 0, 0, 5602, 679, 1, 0, 0, 0, 5603, 5601, 1, 0, 0, 0, 5604, 5617, 3, 688, 344, 0, 5605, 5610, 5, 502, 0, 0, 5606, 5607, 5, 484, 0, 0, 5607, 5609, 3, 98, 49, 0, 5608, 5606, 1, 0, 0, 0, 5609, 5612, 1, 0, 0, 0, 5610, 5608, 1, 0, 0, 0, 5610, 5611, 1, 0, 0, 0, 5611, 5617, 1, 0, 0, 0, 5612, 5610, 1, 0, 0, 0, 5613, 5617, 3, 684, 342, 0, 5614, 5617, 5, 503, 0, 0, 5615, 5617, 5, 498, 0, 0, 5616, 5604, 1, 0, 0, 0, 5616, 5605, 1, 0, 0, 0, 5616, 5613, 1, 0, 0, 0, 5616, 5614, 1, 0, 0, 0, 5616, 5615, 1, 0, 0, 0, 5617, 681, 1, 0, 0, 0, 5618, 5623, 3, 646, 323, 0, 5619, 5620, 5, 483, 0, 0, 5620, 5622, 3, 646, 323, 0, 5621, 5619, 1, 0, 0, 0, 5622, 5625, 1, 0, 0, 0, 5623, 5621, 1, 0, 0, 0, 5623, 5624, 1, 0, 0, 0, 5624, 683, 1, 0, 0, 0, 5625, 5623, 1, 0, 0, 0, 5626, 5631, 3, 686, 343, 0, 5627, 5628, 5, 484, 0, 0, 5628, 5630, 3, 686, 343, 0, 5629, 5627, 1, 0, 0, 0, 5630, 5633, 1, 0, 0, 0, 5631, 5629, 1, 0, 0, 0, 5631, 5632, 1, 0, 0, 0, 5632, 685, 1, 0, 0, 0, 5633, 5631, 1, 0, 0, 0, 5634, 5638, 5, 503, 0, 0, 5635, 5638, 5, 505, 0, 0, 5636, 5638, 3, 708, 354, 0, 5637, 5634, 1, 0, 0, 0, 5637, 5635, 1, 0, 0, 0, 5637, 5636, 1, 0, 0, 0, 5638, 687, 1, 0, 0, 0, 5639, 5645, 5, 499, 0, 0, 5640, 5645, 5, 501, 0, 0, 5641, 5645, 3, 692, 346, 0, 5642, 5645, 5, 283, 0, 0, 5643, 5645, 5, 138, 0, 0, 5644, 5639, 1, 0, 0, 0, 5644, 5640, 1, 0, 0, 0, 5644, 5641, 1, 0, 0, 0, 5644, 5642, 1, 0, 0, 0, 5644, 5643, 1, 0, 0, 0, 5645, 689, 1, 0, 0, 0, 5646, 5655, 5, 489, 0, 0, 5647, 5652, 3, 688, 344, 0, 5648, 5649, 5, 483, 0, 0, 5649, 5651, 3, 688, 344, 0, 5650, 5648, 1, 0, 0, 0, 5651, 5654, 1, 0, 0, 0, 5652, 5650, 1, 0, 0, 0, 5652, 5653, 1, 0, 0, 0, 5653, 5656, 1, 0, 0, 0, 5654, 5652, 1, 0, 0, 0, 5655, 5647, 1, 0, 0, 0, 5655, 5656, 1, 0, 0, 0, 5656, 5657, 1, 0, 0, 0, 5657, 5658, 5, 490, 0, 0, 5658, 691, 1, 0, 0, 0, 5659, 5660, 7, 44, 0, 0, 5660, 693, 1, 0, 0, 0, 5661, 5662, 5, 2, 0, 0, 5662, 695, 1, 0, 0, 0, 5663, 5664, 5, 492, 0, 0, 5664, 5670, 3, 698, 349, 0, 5665, 5666, 5, 485, 0, 0, 5666, 5667, 3, 700, 350, 0, 5667, 5668, 5, 486, 0, 0, 5668, 5671, 1, 0, 0, 0, 5669, 5671, 3, 704, 352, 0, 5670, 5665, 1, 0, 0, 0, 5670, 5669, 1, 0, 0, 0, 5670, 5671, 1, 0, 0, 0, 5671, 697, 1, 0, 0, 0, 5672, 5673, 7, 45, 0, 0, 5673, 699, 1, 0, 0, 0, 5674, 5679, 3, 702, 351, 0, 5675, 5676, 5, 483, 0, 0, 5676, 5678, 3, 702, 351, 0, 5677, 5675, 1, 0, 0, 0, 5678, 5681, 1, 0, 0, 0, 5679, 5677, 1, 0, 0, 0, 5679, 5680, 1, 0, 0, 0, 5680, 701, 1, 0, 0, 0, 5681, 5679, 1, 0, 0, 0, 5682, 5683, 5, 503, 0, 0, 5683, 5684, 5, 491, 0, 0, 5684, 5687, 3, 704, 352, 0, 5685, 5687, 3, 704, 352, 0, 5686, 5682, 1, 0, 0, 0, 5686, 5685, 1, 0, 0, 0, 5687, 703, 1, 0, 0, 0, 5688, 5692, 3, 688, 344, 0, 5689, 5692, 3, 646, 323, 0, 5690, 5692, 3, 684, 342, 0, 5691, 5688, 1, 0, 0, 0, 5691, 5689, 1, 0, 0, 0, 5691, 5690, 1, 0, 0, 0, 5692, 705, 1, 0, 0, 0, 5693, 5694, 7, 46, 0, 0, 5694, 707, 1, 0, 0, 0, 5695, 5696, 7, 47, 0, 0, 5696, 709, 1, 0, 0, 0, 666, 713, 719, 724, 727, 730, 739, 749, 758, 764, 766, 770, 773, 778, 784, 806, 814, 822, 830, 838, 850, 863, 876, 888, 899, 903, 911, 917, 934, 938, 942, 946, 950, 952, 966, 975, 984, 1000, 1009, 1024, 1038, 1042, 1051, 1054, 1062, 1067, 1069, 1127, 1140, 1151, 1160, 1162, 1173, 1179, 1187, 1189, 1210, 1218, 1235, 1259, 1275, 1359, 1369, 1377, 1391, 1398, 1406, 1420, 1433, 1437, 1443, 1446, 1452, 1455, 1461, 1465, 1469, 1475, 1480, 1483, 1485, 1491, 1495, 1499, 1502, 1506, 1511, 1518, 1525, 1529, 1534, 1543, 1549, 1554, 1560, 1565, 1570, 1575, 1579, 1582, 1584, 1590, 1622, 1630, 1651, 1654, 1665, 1670, 1675, 1684, 1689, 1701, 1730, 1740, 1761, 1775, 1782, 1795, 1802, 1810, 1815, 1820, 1826, 1834, 1841, 1845, 1849, 1852, 1869, 1874, 1913, 1928, 1935, 1943, 1950, 1954, 1957, 1963, 1966, 1973, 1977, 1980, 1985, 1992, 1999, 2015, 2020, 2028, 2034, 2039, 2045, 2050, 2056, 2061, 2066, 2071, 2076, 2081, 2086, 2091, 2096, 2101, 2106, 2111, 2116, 2121, 2126, 2131, 2136, 2141, 2146, 2151, 2156, 2161, 2166, 2171, 2176, 2181, 2186, 2191, 2196, 2201, 2206, 2211, 2216, 2221, 2226, 2231, 2236, 2241, 2246, 2251, 2256, 2261, 2266, 2271, 2276, 2281, 2286, 2291, 2296, 2301, 2306, 2311, 2316, 2321, 2326, 2331, 2336, 2341, 2346, 2351, 2356, 2361, 2366, 2371, 2373, 2380, 2385, 2392, 2398, 2401, 2404, 2410, 2413, 2419, 2423, 2429, 2432, 2435, 2440, 2445, 2454, 2456, 2464, 2467, 2471, 2475, 2478, 2487, 2509, 2522, 2527, 2537, 2547, 2552, 2560, 2567, 2571, 2575, 2586, 2593, 2607, 2614, 2618, 2622, 2630, 2634, 2638, 2648, 2650, 2654, 2657, 2662, 2665, 2668, 2672, 2680, 2684, 2691, 2696, 2706, 2709, 2713, 2717, 2724, 2731, 2737, 2751, 2758, 2773, 2777, 2784, 2789, 2793, 2796, 2799, 2803, 2809, 2827, 2832, 2840, 2859, 2924, 2931, 2936, 2966, 2989, 3000, 3007, 3024, 3027, 3036, 3046, 3058, 3070, 3081, 3084, 3097, 3105, 3111, 3117, 3125, 3132, 3140, 3147, 3154, 3166, 3169, 3181, 3205, 3213, 3221, 3241, 3245, 3247, 3255, 3260, 3263, 3273, 3353, 3363, 3371, 3381, 3385, 3387, 3395, 3398, 3403, 3408, 3414, 3418, 3422, 3428, 3434, 3439, 3444, 3449, 3454, 3462, 3473, 3478, 3484, 3488, 3497, 3499, 3501, 3509, 3545, 3548, 3551, 3559, 3566, 3577, 3586, 3592, 3600, 3609, 3617, 3623, 3627, 3636, 3648, 3654, 3656, 3669, 3673, 3685, 3690, 3692, 3707, 3712, 3725, 3733, 3744, 3754, 3763, 3770, 3780, 3791, 3810, 3815, 3826, 3831, 3837, 3841, 3849, 3852, 3868, 3876, 3879, 3886, 3894, 3899, 3902, 3905, 3915, 3918, 3925, 3928, 3936, 3954, 3960, 3963, 3968, 3973, 3983, 4002, 4010, 4022, 4029, 4033, 4047, 4051, 4055, 4060, 4065, 4070, 4077, 4080, 4085, 4115, 4123, 4128, 4133, 4137, 4142, 4146, 4152, 4154, 4161, 4163, 4172, 4177, 4182, 4186, 4191, 4195, 4201, 4203, 4210, 4212, 4214, 4219, 4225, 4231, 4237, 4241, 4247, 4249, 4261, 4270, 4275, 4281, 4283, 4290, 4292, 4303, 4312, 4317, 4321, 4325, 4331, 4333, 4345, 4350, 4363, 4369, 4373, 4380, 4387, 4389, 4400, 4410, 4419, 4422, 4434, 4440, 4449, 4451, 4458, 4460, 4467, 4469, 4476, 4478, 4485, 4487, 4494, 4496, 4503, 4505, 4512, 4514, 4521, 4523, 4530, 4532, 4539, 4541, 4549, 4551, 4579, 4586, 4602, 4607, 4618, 4620, 4653, 4655, 4663, 4665, 4673, 4675, 4683, 4685, 4694, 4704, 4710, 4715, 4717, 4720, 4729, 4731, 4740, 4742, 4750, 4752, 4764, 4766, 4768, 4776, 4782, 4784, 4789, 4791, 4801, 4811, 4852, 4882, 4891, 4927, 4931, 4939, 4942, 4947, 4952, 4958, 4960, 4964, 4968, 4972, 4975, 4982, 4985, 4989, 4996, 5001, 5006, 5009, 5012, 5015, 5018, 5021, 5025, 5028, 5031, 5035, 5038, 5040, 5044, 5054, 5057, 5062, 5067, 5069, 5073, 5080, 5085, 5088, 5094, 5097, 5099, 5102, 5108, 5111, 5116, 5119, 5121, 5133, 5137, 5141, 5146, 5149, 5168, 5173, 5180, 5187, 5193, 5195, 5213, 5224, 5239, 5241, 5249, 5252, 5255, 5258, 5261, 5277, 5281, 5286, 5294, 5302, 5309, 5352, 5357, 5366, 5371, 5374, 5379, 5384, 5400, 5411, 5416, 5420, 5424, 5440, 5459, 5467, 5471, 5485, 5490, 5498, 5504, 5513, 5521, 5525, 5549, 5559, 5563, 5579, 5583, 5590, 5601, 5610, 5616, 5623, 5631, 5637, 5644, 5652, 5655, 5670, 5679, 5686, 5691] \ No newline at end of file diff --git a/mdl/grammar/parser/MDLParser.tokens b/mdl/grammar/parser/MDLParser.tokens index 6588b47..a7624a5 100644 --- a/mdl/grammar/parser/MDLParser.tokens +++ b/mdl/grammar/parser/MDLParser.tokens @@ -302,209 +302,230 @@ PATTERN=301 EXPRESSION=302 XPATH=303 CONSTRAINT=304 -REST=305 -SERVICE=306 -SERVICES=307 -ODATA=308 -BASE=309 -AUTH=310 -AUTHENTICATION=311 -BASIC=312 -NOTHING=313 -OAUTH=314 -OPERATION=315 -METHOD=316 -PATH=317 -TIMEOUT=318 -BODY=319 -RESPONSE=320 -REQUEST=321 -JSON=322 -XML=323 -STATUS=324 -VERSION=325 -GET=326 -POST=327 -PUT=328 -PATCH=329 -API=330 -CLIENT=331 -CLIENTS=332 -PUBLISH=333 -EXPOSE=334 -NAMESPACE_KW=335 -SESSION=336 -GUEST=337 -PAGING=338 -NOT_SUPPORTED=339 -USERNAME=340 -PASSWORD=341 -CONNECTION=342 -DATABASE=343 -QUERY=344 -MAP=345 -MAPPING=346 -IMPORT=347 -INTO=348 -BATCH=349 -LINK=350 -EXPORT=351 -GENERATE=352 -CONNECTOR=353 -EXEC=354 -TABLES=355 -VIEWS=356 -EXPOSED=357 -PARAMETER=358 -PARAMETERS=359 -HEADERS=360 -NAVIGATION=361 -MENU_KW=362 -HOMES=363 -HOME=364 -LOGIN=365 -FOUND=366 -MODULES=367 -ENTITIES=368 -ASSOCIATIONS=369 -MICROFLOWS=370 -NANOFLOWS=371 -WORKFLOWS=372 -ENUMERATIONS=373 -CONSTANTS=374 -CONNECTIONS=375 -DEFINE=376 -FRAGMENT=377 -FRAGMENTS=378 -INSERT=379 -BEFORE=380 -AFTER=381 -UPDATE=382 -REFRESH=383 -CHECK=384 -BUILD=385 -EXECUTE=386 -SCRIPT=387 -LINT=388 -RULES=389 -TEXT=390 -SARIF=391 -MESSAGE=392 -COMMENT=393 -CATALOG=394 -FORCE=395 -BACKGROUND=396 -CALLERS=397 -CALLEES=398 -REFERENCES=399 -TRANSITIVE=400 -IMPACT=401 -DEPTH=402 -STRUCTURE=403 -TYPE=404 -VALUE=405 -SINGLE=406 -MULTIPLE=407 -NONE=408 -BOTH=409 -TO=410 -OF=411 -OVER=412 -FOR=413 -REPLACE=414 -MEMBERS=415 -ATTRIBUTE_NAME=416 -FORMAT=417 -SQL=418 -WITHOUT=419 -DRY=420 -RUN=421 -WIDGETTYPE=422 -V3=423 -BUSINESS=424 -EVENT=425 -SUBSCRIBE=426 -SETTINGS=427 -CONFIGURATION=428 -SECURITY=429 -ROLE=430 -ROLES=431 -GRANT=432 -REVOKE=433 -PRODUCTION=434 -PROTOTYPE=435 -MANAGE=436 -DEMO=437 -MATRIX=438 -APPLY=439 -ACCESS=440 -LEVEL=441 -USER=442 -READ=443 -WRITE=444 -DESCRIPTION=445 -OFF=446 -USERS=447 -NOT_EQUALS=448 -LESS_THAN_OR_EQUAL=449 -GREATER_THAN_OR_EQUAL=450 -EQUALS=451 -LESS_THAN=452 -GREATER_THAN=453 -PLUS=454 -MINUS=455 -STAR=456 -SLASH=457 -PERCENT=458 -MOD=459 -DIV=460 -SEMICOLON=461 -COMMA=462 -DOT=463 -LPAREN=464 -RPAREN=465 -LBRACE=466 -RBRACE=467 -LBRACKET=468 -RBRACKET=469 -COLON=470 -AT=471 -PIPE=472 -DOUBLE_COLON=473 -ARROW=474 -QUESTION=475 -HASH=476 -MENDIX_TOKEN=477 -STRING_LITERAL=478 -DOLLAR_STRING=479 -NUMBER_LITERAL=480 -VARIABLE=481 -IDENTIFIER=482 -HYPHENATED_ID=483 -QUOTED_IDENTIFIER=484 -'<='=449 -'>='=450 -'='=451 -'<'=452 -'>'=453 -'+'=454 -'-'=455 -'*'=456 -'/'=457 -'%'=458 -';'=461 -','=462 -'.'=463 -'('=464 -')'=465 -'{'=466 -'}'=467 -'['=468 -']'=469 -':'=470 -'@'=471 -'|'=472 -'::'=473 -'->'=474 -'?'=475 -'#'=476 +CALCULATED=305 +REST=306 +SERVICE=307 +SERVICES=308 +ODATA=309 +BASE=310 +AUTH=311 +AUTHENTICATION=312 +BASIC=313 +NOTHING=314 +OAUTH=315 +OPERATION=316 +METHOD=317 +PATH=318 +TIMEOUT=319 +BODY=320 +RESPONSE=321 +REQUEST=322 +JSON=323 +XML=324 +STATUS=325 +VERSION=326 +GET=327 +POST=328 +PUT=329 +PATCH=330 +API=331 +CLIENT=332 +CLIENTS=333 +PUBLISH=334 +EXPOSE=335 +NAMESPACE_KW=336 +SESSION=337 +GUEST=338 +PAGING=339 +NOT_SUPPORTED=340 +USERNAME=341 +PASSWORD=342 +CONNECTION=343 +DATABASE=344 +QUERY=345 +MAP=346 +MAPPING=347 +IMPORT=348 +INTO=349 +BATCH=350 +LINK=351 +EXPORT=352 +GENERATE=353 +CONNECTOR=354 +EXEC=355 +TABLES=356 +VIEWS=357 +EXPOSED=358 +PARAMETER=359 +PARAMETERS=360 +HEADERS=361 +NAVIGATION=362 +MENU_KW=363 +HOMES=364 +HOME=365 +LOGIN=366 +FOUND=367 +MODULES=368 +ENTITIES=369 +ASSOCIATIONS=370 +MICROFLOWS=371 +NANOFLOWS=372 +WORKFLOWS=373 +ENUMERATIONS=374 +CONSTANTS=375 +CONNECTIONS=376 +DEFINE=377 +FRAGMENT=378 +FRAGMENTS=379 +INSERT=380 +BEFORE=381 +AFTER=382 +UPDATE=383 +REFRESH=384 +CHECK=385 +BUILD=386 +EXECUTE=387 +SCRIPT=388 +LINT=389 +RULES=390 +TEXT=391 +SARIF=392 +MESSAGE=393 +COMMENT=394 +CATALOG=395 +FORCE=396 +BACKGROUND=397 +CALLERS=398 +CALLEES=399 +REFERENCES=400 +TRANSITIVE=401 +IMPACT=402 +DEPTH=403 +STRUCTURE=404 +TYPE=405 +VALUE=406 +SINGLE=407 +MULTIPLE=408 +NONE=409 +BOTH=410 +TO=411 +OF=412 +OVER=413 +FOR=414 +REPLACE=415 +MEMBERS=416 +ATTRIBUTE_NAME=417 +FORMAT=418 +SQL=419 +WITHOUT=420 +DRY=421 +RUN=422 +WIDGETTYPE=423 +V3=424 +BUSINESS=425 +EVENT=426 +SUBSCRIBE=427 +SETTINGS=428 +CONFIGURATION=429 +SECURITY=430 +ROLE=431 +ROLES=432 +GRANT=433 +REVOKE=434 +PRODUCTION=435 +PROTOTYPE=436 +MANAGE=437 +DEMO=438 +MATRIX=439 +APPLY=440 +ACCESS=441 +LEVEL=442 +USER=443 +TASK=444 +DECISION=445 +SPLIT=446 +OUTCOMES=447 +TARGETING=448 +NOTIFICATION=449 +TIMER=450 +JUMP=451 +DUE=452 +OVERVIEW=453 +DATE=454 +PARALLEL=455 +WAIT=456 +ANNOTATION=457 +BOUNDARY=458 +INTERRUPTING=459 +NON=460 +MULTI=461 +BY=462 +READ=463 +WRITE=464 +DESCRIPTION=465 +DISPLAY=466 +OFF=467 +USERS=468 +NOT_EQUALS=469 +LESS_THAN_OR_EQUAL=470 +GREATER_THAN_OR_EQUAL=471 +EQUALS=472 +LESS_THAN=473 +GREATER_THAN=474 +PLUS=475 +MINUS=476 +STAR=477 +SLASH=478 +PERCENT=479 +MOD=480 +DIV=481 +SEMICOLON=482 +COMMA=483 +DOT=484 +LPAREN=485 +RPAREN=486 +LBRACE=487 +RBRACE=488 +LBRACKET=489 +RBRACKET=490 +COLON=491 +AT=492 +PIPE=493 +DOUBLE_COLON=494 +ARROW=495 +QUESTION=496 +HASH=497 +MENDIX_TOKEN=498 +STRING_LITERAL=499 +DOLLAR_STRING=500 +NUMBER_LITERAL=501 +VARIABLE=502 +IDENTIFIER=503 +HYPHENATED_ID=504 +QUOTED_IDENTIFIER=505 +'<='=470 +'>='=471 +'='=472 +'<'=473 +'>'=474 +'+'=475 +'-'=476 +'*'=477 +'/'=478 +'%'=479 +';'=482 +','=483 +'.'=484 +'('=485 +')'=486 +'{'=487 +'}'=488 +'['=489 +']'=490 +':'=491 +'@'=492 +'|'=493 +'::'=494 +'->'=495 +'?'=496 +'#'=497 diff --git a/mdl/grammar/parser/mdl_lexer.go b/mdl/grammar/parser/mdl_lexer.go index 8d28d19..83487ca 100644 --- a/mdl/grammar/parser/mdl_lexer.go +++ b/mdl/grammar/parser/mdl_lexer.go @@ -69,10 +69,11 @@ func mdllexerLexerInit() { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", - "", "", "", "", "", "", "", "'<='", "'>='", "'='", "'<'", "'>'", "'+'", - "'-'", "'*'", "'/'", "'%'", "", "", "';'", "','", "'.'", "'('", "')'", - "'{'", "'}'", "'['", "']'", "':'", "'@'", "'|'", "'::'", "'->'", "'?'", - "'#'", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "'<='", "'>='", "'='", "'<'", + "'>'", "'+'", "'-'", "'*'", "'/'", "'%'", "", "", "';'", "','", "'.'", + "'('", "')'", "'{'", "'}'", "'['", "']'", "':'", "'@'", "'|'", "'::'", + "'->'", "'?'", "'#'", } staticData.SymbolicNames = []string{ "", "WS", "DOC_COMMENT", "BLOCK_COMMENT", "LINE_COMMENT", "IS_NOT_NULL", @@ -122,33 +123,35 @@ func mdllexerLexerInit() { "OR", "NOT", "NULL", "IN", "BETWEEN", "LIKE", "MATCH", "EXISTS", "UNIQUE", "DEFAULT", "TRUE", "FALSE", "VALIDATION", "FEEDBACK", "RULE", "REQUIRED", "ERROR", "RAISE", "RANGE", "REGEX", "PATTERN", "EXPRESSION", "XPATH", - "CONSTRAINT", "REST", "SERVICE", "SERVICES", "ODATA", "BASE", "AUTH", - "AUTHENTICATION", "BASIC", "NOTHING", "OAUTH", "OPERATION", "METHOD", - "PATH", "TIMEOUT", "BODY", "RESPONSE", "REQUEST", "JSON", "XML", "STATUS", - "VERSION", "GET", "POST", "PUT", "PATCH", "API", "CLIENT", "CLIENTS", - "PUBLISH", "EXPOSE", "NAMESPACE_KW", "SESSION", "GUEST", "PAGING", "NOT_SUPPORTED", - "USERNAME", "PASSWORD", "CONNECTION", "DATABASE", "QUERY", "MAP", "MAPPING", - "IMPORT", "INTO", "BATCH", "LINK", "EXPORT", "GENERATE", "CONNECTOR", - "EXEC", "TABLES", "VIEWS", "EXPOSED", "PARAMETER", "PARAMETERS", "HEADERS", - "NAVIGATION", "MENU_KW", "HOMES", "HOME", "LOGIN", "FOUND", "MODULES", - "ENTITIES", "ASSOCIATIONS", "MICROFLOWS", "NANOFLOWS", "WORKFLOWS", - "ENUMERATIONS", "CONSTANTS", "CONNECTIONS", "DEFINE", "FRAGMENT", "FRAGMENTS", - "INSERT", "BEFORE", "AFTER", "UPDATE", "REFRESH", "CHECK", "BUILD", - "EXECUTE", "SCRIPT", "LINT", "RULES", "TEXT", "SARIF", "MESSAGE", "COMMENT", - "CATALOG", "FORCE", "BACKGROUND", "CALLERS", "CALLEES", "REFERENCES", + "CONSTRAINT", "CALCULATED", "REST", "SERVICE", "SERVICES", "ODATA", + "BASE", "AUTH", "AUTHENTICATION", "BASIC", "NOTHING", "OAUTH", "OPERATION", + "METHOD", "PATH", "TIMEOUT", "BODY", "RESPONSE", "REQUEST", "JSON", + "XML", "STATUS", "VERSION", "GET", "POST", "PUT", "PATCH", "API", "CLIENT", + "CLIENTS", "PUBLISH", "EXPOSE", "NAMESPACE_KW", "SESSION", "GUEST", + "PAGING", "NOT_SUPPORTED", "USERNAME", "PASSWORD", "CONNECTION", "DATABASE", + "QUERY", "MAP", "MAPPING", "IMPORT", "INTO", "BATCH", "LINK", "EXPORT", + "GENERATE", "CONNECTOR", "EXEC", "TABLES", "VIEWS", "EXPOSED", "PARAMETER", + "PARAMETERS", "HEADERS", "NAVIGATION", "MENU_KW", "HOMES", "HOME", "LOGIN", + "FOUND", "MODULES", "ENTITIES", "ASSOCIATIONS", "MICROFLOWS", "NANOFLOWS", + "WORKFLOWS", "ENUMERATIONS", "CONSTANTS", "CONNECTIONS", "DEFINE", "FRAGMENT", + "FRAGMENTS", "INSERT", "BEFORE", "AFTER", "UPDATE", "REFRESH", "CHECK", + "BUILD", "EXECUTE", "SCRIPT", "LINT", "RULES", "TEXT", "SARIF", "MESSAGE", + "COMMENT", "CATALOG", "FORCE", "BACKGROUND", "CALLERS", "CALLEES", "REFERENCES", "TRANSITIVE", "IMPACT", "DEPTH", "STRUCTURE", "TYPE", "VALUE", "SINGLE", "MULTIPLE", "NONE", "BOTH", "TO", "OF", "OVER", "FOR", "REPLACE", "MEMBERS", "ATTRIBUTE_NAME", "FORMAT", "SQL", "WITHOUT", "DRY", "RUN", "WIDGETTYPE", "V3", "BUSINESS", "EVENT", "SUBSCRIBE", "SETTINGS", "CONFIGURATION", "SECURITY", "ROLE", "ROLES", "GRANT", "REVOKE", "PRODUCTION", "PROTOTYPE", - "MANAGE", "DEMO", "MATRIX", "APPLY", "ACCESS", "LEVEL", "USER", "READ", - "WRITE", "DESCRIPTION", "OFF", "USERS", "NOT_EQUALS", "LESS_THAN_OR_EQUAL", - "GREATER_THAN_OR_EQUAL", "EQUALS", "LESS_THAN", "GREATER_THAN", "PLUS", - "MINUS", "STAR", "SLASH", "PERCENT", "MOD", "DIV", "SEMICOLON", "COMMA", - "DOT", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", - "COLON", "AT", "PIPE", "DOUBLE_COLON", "ARROW", "QUESTION", "HASH", - "MENDIX_TOKEN", "STRING_LITERAL", "DOLLAR_STRING", "NUMBER_LITERAL", - "VARIABLE", "IDENTIFIER", "HYPHENATED_ID", "QUOTED_IDENTIFIER", + "MANAGE", "DEMO", "MATRIX", "APPLY", "ACCESS", "LEVEL", "USER", "TASK", + "DECISION", "SPLIT", "OUTCOMES", "TARGETING", "NOTIFICATION", "TIMER", + "JUMP", "DUE", "OVERVIEW", "DATE", "PARALLEL", "WAIT", "ANNOTATION", + "BOUNDARY", "INTERRUPTING", "NON", "MULTI", "BY", "READ", "WRITE", "DESCRIPTION", + "DISPLAY", "OFF", "USERS", "NOT_EQUALS", "LESS_THAN_OR_EQUAL", "GREATER_THAN_OR_EQUAL", + "EQUALS", "LESS_THAN", "GREATER_THAN", "PLUS", "MINUS", "STAR", "SLASH", + "PERCENT", "MOD", "DIV", "SEMICOLON", "COMMA", "DOT", "LPAREN", "RPAREN", + "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "COLON", "AT", "PIPE", "DOUBLE_COLON", + "ARROW", "QUESTION", "HASH", "MENDIX_TOKEN", "STRING_LITERAL", "DOLLAR_STRING", + "NUMBER_LITERAL", "VARIABLE", "IDENTIFIER", "HYPHENATED_ID", "QUOTED_IDENTIFIER", } staticData.RuleNames = []string{ "WS", "DOC_COMMENT", "BLOCK_COMMENT", "LINE_COMMENT", "IS_NOT_NULL", @@ -198,40 +201,42 @@ func mdllexerLexerInit() { "OR", "NOT", "NULL", "IN", "BETWEEN", "LIKE", "MATCH", "EXISTS", "UNIQUE", "DEFAULT", "TRUE", "FALSE", "VALIDATION", "FEEDBACK", "RULE", "REQUIRED", "ERROR", "RAISE", "RANGE", "REGEX", "PATTERN", "EXPRESSION", "XPATH", - "CONSTRAINT", "REST", "SERVICE", "SERVICES", "ODATA", "BASE", "AUTH", - "AUTHENTICATION", "BASIC", "NOTHING", "OAUTH", "OPERATION", "METHOD", - "PATH", "TIMEOUT", "BODY", "RESPONSE", "REQUEST", "JSON", "XML", "STATUS", - "VERSION", "GET", "POST", "PUT", "PATCH", "API", "CLIENT", "CLIENTS", - "PUBLISH", "EXPOSE", "NAMESPACE_KW", "SESSION", "GUEST", "PAGING", "NOT_SUPPORTED", - "USERNAME", "PASSWORD", "CONNECTION", "DATABASE", "QUERY", "MAP", "MAPPING", - "IMPORT", "INTO", "BATCH", "LINK", "EXPORT", "GENERATE", "CONNECTOR", - "EXEC", "TABLES", "VIEWS", "EXPOSED", "PARAMETER", "PARAMETERS", "HEADERS", - "NAVIGATION", "MENU_KW", "HOMES", "HOME", "LOGIN", "FOUND", "MODULES", - "ENTITIES", "ASSOCIATIONS", "MICROFLOWS", "NANOFLOWS", "WORKFLOWS", - "ENUMERATIONS", "CONSTANTS", "CONNECTIONS", "DEFINE", "FRAGMENT", "FRAGMENTS", - "INSERT", "BEFORE", "AFTER", "UPDATE", "REFRESH", "CHECK", "BUILD", - "EXECUTE", "SCRIPT", "LINT", "RULES", "TEXT", "SARIF", "MESSAGE", "COMMENT", - "CATALOG", "FORCE", "BACKGROUND", "CALLERS", "CALLEES", "REFERENCES", + "CONSTRAINT", "CALCULATED", "REST", "SERVICE", "SERVICES", "ODATA", + "BASE", "AUTH", "AUTHENTICATION", "BASIC", "NOTHING", "OAUTH", "OPERATION", + "METHOD", "PATH", "TIMEOUT", "BODY", "RESPONSE", "REQUEST", "JSON", + "XML", "STATUS", "VERSION", "GET", "POST", "PUT", "PATCH", "API", "CLIENT", + "CLIENTS", "PUBLISH", "EXPOSE", "NAMESPACE_KW", "SESSION", "GUEST", + "PAGING", "NOT_SUPPORTED", "USERNAME", "PASSWORD", "CONNECTION", "DATABASE", + "QUERY", "MAP", "MAPPING", "IMPORT", "INTO", "BATCH", "LINK", "EXPORT", + "GENERATE", "CONNECTOR", "EXEC", "TABLES", "VIEWS", "EXPOSED", "PARAMETER", + "PARAMETERS", "HEADERS", "NAVIGATION", "MENU_KW", "HOMES", "HOME", "LOGIN", + "FOUND", "MODULES", "ENTITIES", "ASSOCIATIONS", "MICROFLOWS", "NANOFLOWS", + "WORKFLOWS", "ENUMERATIONS", "CONSTANTS", "CONNECTIONS", "DEFINE", "FRAGMENT", + "FRAGMENTS", "INSERT", "BEFORE", "AFTER", "UPDATE", "REFRESH", "CHECK", + "BUILD", "EXECUTE", "SCRIPT", "LINT", "RULES", "TEXT", "SARIF", "MESSAGE", + "COMMENT", "CATALOG", "FORCE", "BACKGROUND", "CALLERS", "CALLEES", "REFERENCES", "TRANSITIVE", "IMPACT", "DEPTH", "STRUCTURE", "TYPE", "VALUE", "SINGLE", "MULTIPLE", "NONE", "BOTH", "TO", "OF", "OVER", "FOR", "REPLACE", "MEMBERS", "ATTRIBUTE_NAME", "FORMAT", "SQL", "WITHOUT", "DRY", "RUN", "WIDGETTYPE", "V3", "BUSINESS", "EVENT", "SUBSCRIBE", "SETTINGS", "CONFIGURATION", "SECURITY", "ROLE", "ROLES", "GRANT", "REVOKE", "PRODUCTION", "PROTOTYPE", - "MANAGE", "DEMO", "MATRIX", "APPLY", "ACCESS", "LEVEL", "USER", "READ", - "WRITE", "DESCRIPTION", "OFF", "USERS", "NOT_EQUALS", "LESS_THAN_OR_EQUAL", - "GREATER_THAN_OR_EQUAL", "EQUALS", "LESS_THAN", "GREATER_THAN", "PLUS", - "MINUS", "STAR", "SLASH", "PERCENT", "MOD", "DIV", "SEMICOLON", "COMMA", - "DOT", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", - "COLON", "AT", "PIPE", "DOUBLE_COLON", "ARROW", "QUESTION", "HASH", - "MENDIX_TOKEN", "STRING_LITERAL", "DOLLAR_STRING", "NUMBER_LITERAL", - "VARIABLE", "IDENTIFIER", "HYPHENATED_ID", "QUOTED_IDENTIFIER", "ID_START", - "ID_BODY", "DIGIT", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", - "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", - "Y", "Z", + "MANAGE", "DEMO", "MATRIX", "APPLY", "ACCESS", "LEVEL", "USER", "TASK", + "DECISION", "SPLIT", "OUTCOMES", "TARGETING", "NOTIFICATION", "TIMER", + "JUMP", "DUE", "OVERVIEW", "DATE", "PARALLEL", "WAIT", "ANNOTATION", + "BOUNDARY", "INTERRUPTING", "NON", "MULTI", "BY", "READ", "WRITE", "DESCRIPTION", + "DISPLAY", "OFF", "USERS", "NOT_EQUALS", "LESS_THAN_OR_EQUAL", "GREATER_THAN_OR_EQUAL", + "EQUALS", "LESS_THAN", "GREATER_THAN", "PLUS", "MINUS", "STAR", "SLASH", + "PERCENT", "MOD", "DIV", "SEMICOLON", "COMMA", "DOT", "LPAREN", "RPAREN", + "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "COLON", "AT", "PIPE", "DOUBLE_COLON", + "ARROW", "QUESTION", "HASH", "MENDIX_TOKEN", "STRING_LITERAL", "DOLLAR_STRING", + "NUMBER_LITERAL", "VARIABLE", "IDENTIFIER", "HYPHENATED_ID", "QUOTED_IDENTIFIER", + "ID_START", "ID_BODY", "DIGIT", "A", "B", "C", "D", "E", "F", "G", "H", + "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", + "W", "X", "Y", "Z", } staticData.PredictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ - 4, 0, 484, 5030, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, + 4, 0, 505, 5232, 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, @@ -341,2351 +346,2466 @@ func mdllexerLexerInit() { 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, - 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 1, 0, 4, - 0, 1029, 8, 0, 11, 0, 12, 0, 1030, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 5, 1, 1040, 8, 1, 10, 1, 12, 1, 1043, 9, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 1, 2, 1, 2, 1, 2, 5, 2, 1052, 8, 2, 10, 2, 12, 2, 1055, 9, 2, 1, 2, - 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 1066, 8, 3, 10, 3, - 12, 3, 1069, 9, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 4, 4, 1076, 8, 4, 11, - 4, 12, 4, 1077, 1, 4, 1, 4, 1, 4, 1, 4, 4, 4, 1084, 8, 4, 11, 4, 12, 4, - 1085, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 4, 5, 1096, 8, 5, - 11, 5, 12, 5, 1097, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, - 6, 4, 6, 1109, 8, 6, 11, 6, 12, 6, 1110, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, - 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 4, 7, 1124, 8, 7, 11, 7, 12, 7, 1125, - 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 4, 8, 1137, 8, 8, - 11, 8, 12, 8, 1138, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 4, - 9, 1149, 8, 9, 11, 9, 12, 9, 1150, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, - 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, - 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, - 1, 11, 3, 11, 1181, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, - 12, 1, 12, 1, 12, 4, 12, 1192, 8, 12, 11, 12, 12, 12, 1193, 1, 12, 1, 12, - 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1206, 8, - 13, 11, 13, 12, 13, 1207, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1214, 8, 13, - 11, 13, 12, 13, 1215, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, + 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, + 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, + 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, + 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, + 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, + 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 1, 0, 4, 0, 1071, 8, 0, 11, 0, + 12, 0, 1072, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1082, 8, 1, + 10, 1, 12, 1, 1085, 9, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, + 2, 1094, 8, 2, 10, 2, 12, 2, 1097, 9, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, + 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 1108, 8, 3, 10, 3, 12, 3, 1111, 9, 3, 1, + 3, 1, 3, 1, 4, 1, 4, 1, 4, 4, 4, 1118, 8, 4, 11, 4, 12, 4, 1119, 1, 4, + 1, 4, 1, 4, 1, 4, 4, 4, 1126, 8, 4, 11, 4, 12, 4, 1127, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 4, 5, 1138, 8, 5, 11, 5, 12, 5, 1139, + 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 4, 6, 1151, 8, 6, + 11, 6, 12, 6, 1152, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, + 7, 1, 7, 1, 7, 4, 7, 1166, 8, 7, 11, 7, 12, 7, 1167, 1, 7, 1, 7, 1, 7, + 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 4, 8, 1179, 8, 8, 11, 8, 12, 8, 1180, + 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 4, 9, 1191, 8, 9, 11, 9, + 12, 9, 1192, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, + 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, + 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1223, + 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 4, + 12, 1234, 8, 12, 11, 12, 12, 12, 1235, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, + 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1248, 8, 13, 11, 13, 12, 13, + 1249, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 1256, 8, 13, 11, 13, 12, 13, 1257, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, - 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1271, 8, 13, 1, 14, 1, 14, 1, 14, 1, - 14, 1, 14, 1, 14, 1, 14, 4, 14, 1280, 8, 14, 11, 14, 12, 14, 1281, 1, 14, - 1, 14, 1, 14, 1, 14, 4, 14, 1288, 8, 14, 11, 14, 12, 14, 1289, 1, 14, 1, - 14, 1, 14, 1, 14, 1, 14, 4, 14, 1297, 8, 14, 11, 14, 12, 14, 1298, 1, 14, - 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, + 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, + 13, 3, 13, 1313, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, + 4, 14, 1322, 8, 14, 11, 14, 12, 14, 1323, 1, 14, 1, 14, 1, 14, 1, 14, 4, + 14, 1330, 8, 14, 11, 14, 12, 14, 1331, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, + 4, 14, 1339, 8, 14, 11, 14, 12, 14, 1340, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, - 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1363, - 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 4, 15, 1372, 8, - 15, 11, 15, 12, 15, 1373, 1, 15, 1, 15, 1, 15, 4, 15, 1379, 8, 15, 11, - 15, 12, 15, 1380, 1, 15, 1, 15, 1, 15, 4, 15, 1386, 8, 15, 11, 15, 12, - 15, 1387, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, + 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1405, 8, 14, 1, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 4, 15, 1414, 8, 15, 11, 15, 12, 15, 1415, + 1, 15, 1, 15, 1, 15, 4, 15, 1421, 8, 15, 11, 15, 12, 15, 1422, 1, 15, 1, + 15, 1, 15, 4, 15, 1428, 8, 15, 11, 15, 12, 15, 1429, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, - 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1446, 8, 15, 1, 16, 1, 16, 1, - 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, - 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, - 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, - 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, - 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, - 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, - 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, - 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, - 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, - 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, - 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, - 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, - 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, - 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, - 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, - 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, - 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, - 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, - 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, - 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, - 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, - 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, - 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, - 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, - 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, - 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, - 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, - 1, 51, 1, 51, 3, 51, 1736, 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, - 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, - 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, - 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, - 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, - 56, 1, 56, 1, 56, 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, 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, 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, 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, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 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, 68, 1, - 69, 1, 69, 1, 69, 1, 69, 1, 69, 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, 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, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, - 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, - 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, - 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 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, 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, 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, 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, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, - 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, - 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 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, 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, 100, 1, 100, 1, 100, 1, 100, 1, 100, - 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, - 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, - 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, - 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, - 1, 106, 1, 106, 1, 106, 1, 106, 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, 110, 1, 110, 1, 110, 1, 110, - 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, 115, 1, 115, - 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, - 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, - 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, - 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, - 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, 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, 126, 1, 126, 1, 127, 1, 127, 1, 127, - 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, - 1, 128, 1, 128, 1, 128, 1, 128, 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, 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, 135, 1, 135, 1, 135, - 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, - 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, - 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, - 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, - 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, - 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, - 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, - 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, - 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, - 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, - 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, - 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, - 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, - 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, - 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, - 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, - 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, - 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, - 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, - 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, - 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, - 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 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, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, - 1, 159, 1, 159, 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, 161, 1, 161, 1, 161, - 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, - 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, - 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, - 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, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, - 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, - 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, - 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, - 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, - 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, - 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, - 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, - 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, - 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, - 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, - 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, - 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, - 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, - 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, - 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, - 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, - 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, - 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, - 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, - 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, - 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, - 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, - 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, - 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 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, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, - 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, - 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, - 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, - 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, - 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, - 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, - 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, - 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, - 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, - 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, - 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, - 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, - 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, - 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, - 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, - 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, - 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, - 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, - 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, - 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, - 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, - 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, - 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, - 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, - 1, 212, 1, 212, 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, 214, 1, 214, 1, 214, 1, 215, - 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, - 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, - 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, - 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, - 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, - 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, - 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, - 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, - 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, - 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, - 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, - 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, - 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, - 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, - 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, - 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, - 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, - 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, - 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, - 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, - 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, - 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, - 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, - 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, - 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, - 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, - 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, - 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, - 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, - 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, - 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, - 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, - 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, - 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, - 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, - 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, - 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, - 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, - 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, - 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, - 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, - 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, - 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, - 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, - 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, - 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, - 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, - 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, - 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, - 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, - 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, - 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, - 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, - 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, - 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 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, 275, 1, 275, 1, 275, 1, 276, - 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, - 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, - 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, - 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, - 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, - 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, - 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, - 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, - 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, - 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, - 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, - 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, - 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, - 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, - 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, - 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, - 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, - 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, - 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, - 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, - 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, - 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, - 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, - 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, - 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, - 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, - 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, - 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, - 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, - 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, - 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, - 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, - 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, - 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, - 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, - 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, - 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, - 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, - 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, - 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, - 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, - 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, - 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, - 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, - 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, - 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, - 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, - 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, - 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, - 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, - 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, - 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, - 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, - 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, - 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, - 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, - 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, - 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, - 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, - 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, - 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, - 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, - 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, - 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, - 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, - 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, - 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, - 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, - 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, - 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, - 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, - 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, - 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, - 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, - 1, 369, 1, 369, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, - 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, - 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, - 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, - 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, - 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, - 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, - 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, - 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, - 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, - 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, - 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, 381, - 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, - 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, - 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, - 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, - 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 388, - 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, 389, 1, 389, - 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 391, 1, 391, - 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, - 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, - 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, - 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, - 1, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, - 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, - 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, - 1, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, - 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, - 1, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, - 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, - 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 404, 1, 404, 1, 404, - 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, - 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, - 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, - 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, 1, 411, - 1, 411, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 413, - 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, - 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, - 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, - 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, - 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, - 1, 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, - 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, - 1, 421, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 423, 1, 423, - 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, - 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, - 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, - 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, - 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, - 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, - 1, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 430, 1, 430, 1, 430, - 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, - 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, - 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, - 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, - 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, - 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, - 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 439, - 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, - 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 442, - 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, - 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, - 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, - 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, - 3, 447, 4794, 8, 447, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, - 450, 1, 450, 1, 451, 1, 451, 1, 452, 1, 452, 1, 453, 1, 453, 1, 454, 1, - 454, 1, 455, 1, 455, 1, 456, 1, 456, 1, 457, 1, 457, 1, 458, 1, 458, 1, - 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 461, 1, - 461, 1, 462, 1, 462, 1, 463, 1, 463, 1, 464, 1, 464, 1, 465, 1, 465, 1, - 466, 1, 466, 1, 467, 1, 467, 1, 468, 1, 468, 1, 469, 1, 469, 1, 470, 1, - 470, 1, 471, 1, 471, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, - 474, 1, 474, 1, 475, 1, 475, 1, 476, 1, 476, 1, 476, 1, 476, 5, 476, 4864, - 8, 476, 10, 476, 12, 476, 4867, 9, 476, 1, 476, 1, 476, 1, 476, 1, 477, - 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 5, 477, 4878, 8, 477, 10, 477, - 12, 477, 4881, 9, 477, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 1, 478, - 5, 478, 4889, 8, 478, 10, 478, 12, 478, 4892, 9, 478, 1, 478, 1, 478, 1, - 478, 1, 479, 3, 479, 4898, 8, 479, 1, 479, 4, 479, 4901, 8, 479, 11, 479, - 12, 479, 4902, 1, 479, 1, 479, 4, 479, 4907, 8, 479, 11, 479, 12, 479, - 4908, 3, 479, 4911, 8, 479, 1, 479, 1, 479, 3, 479, 4915, 8, 479, 1, 479, - 4, 479, 4918, 8, 479, 11, 479, 12, 479, 4919, 3, 479, 4922, 8, 479, 1, - 480, 1, 480, 4, 480, 4926, 8, 480, 11, 480, 12, 480, 4927, 1, 481, 1, 481, - 5, 481, 4932, 8, 481, 10, 481, 12, 481, 4935, 9, 481, 1, 482, 1, 482, 5, - 482, 4939, 8, 482, 10, 482, 12, 482, 4942, 9, 482, 1, 482, 4, 482, 4945, - 8, 482, 11, 482, 12, 482, 4946, 1, 482, 5, 482, 4950, 8, 482, 10, 482, - 12, 482, 4953, 9, 482, 1, 483, 1, 483, 5, 483, 4957, 8, 483, 10, 483, 12, - 483, 4960, 9, 483, 1, 483, 1, 483, 1, 483, 5, 483, 4965, 8, 483, 10, 483, - 12, 483, 4968, 9, 483, 1, 483, 3, 483, 4971, 8, 483, 1, 484, 1, 484, 1, - 485, 1, 485, 1, 486, 1, 486, 1, 487, 1, 487, 1, 488, 1, 488, 1, 489, 1, - 489, 1, 490, 1, 490, 1, 491, 1, 491, 1, 492, 1, 492, 1, 493, 1, 493, 1, - 494, 1, 494, 1, 495, 1, 495, 1, 496, 1, 496, 1, 497, 1, 497, 1, 498, 1, - 498, 1, 499, 1, 499, 1, 500, 1, 500, 1, 501, 1, 501, 1, 502, 1, 502, 1, - 503, 1, 503, 1, 504, 1, 504, 1, 505, 1, 505, 1, 506, 1, 506, 1, 507, 1, - 507, 1, 508, 1, 508, 1, 509, 1, 509, 1, 510, 1, 510, 1, 511, 1, 511, 1, - 512, 1, 512, 4, 1041, 1053, 4865, 4890, 0, 513, 1, 1, 3, 2, 5, 3, 7, 4, - 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, - 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, - 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, - 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, - 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, - 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, - 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, - 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, - 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, - 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, - 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, - 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, - 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, - 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, - 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, - 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, - 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, - 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, - 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, - 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, - 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, - 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, - 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, - 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, - 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, - 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, - 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, - 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, - 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, - 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, - 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, - 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, 255, 511, - 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, 525, 263, - 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, 270, 541, - 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, 555, 278, - 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, 285, 571, - 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, 585, 293, - 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, 300, 601, - 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, 615, 308, - 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, 315, 631, - 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, 645, 323, - 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, 330, 661, - 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, 675, 338, - 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, 345, 691, - 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, 705, 353, - 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, 360, 721, - 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, 735, 368, - 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, 375, 751, - 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, 765, 383, - 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, 779, 390, 781, - 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, 397, 795, 398, - 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, 809, 405, 811, - 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, 412, 825, 413, - 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, 839, 420, 841, - 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, 427, 855, 428, - 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, 869, 435, 871, - 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, 442, 885, 443, - 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, 899, 450, 901, - 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, 457, 915, 458, - 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, 929, 465, 931, - 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, 472, 945, 473, - 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, 959, 480, 961, - 481, 963, 482, 965, 483, 967, 484, 969, 0, 971, 0, 973, 0, 975, 0, 977, - 0, 979, 0, 981, 0, 983, 0, 985, 0, 987, 0, 989, 0, 991, 0, 993, 0, 995, - 0, 997, 0, 999, 0, 1001, 0, 1003, 0, 1005, 0, 1007, 0, 1009, 0, 1011, 0, - 1013, 0, 1015, 0, 1017, 0, 1019, 0, 1021, 0, 1023, 0, 1025, 0, 1, 0, 35, - 2, 0, 9, 13, 32, 32, 2, 0, 10, 10, 13, 13, 4, 0, 10, 10, 13, 13, 39, 39, - 92, 92, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 3, 0, 10, 10, 13, - 13, 34, 34, 3, 0, 10, 10, 13, 13, 96, 96, 3, 0, 65, 90, 95, 95, 97, 122, - 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1, 0, 48, 57, 2, 0, 65, 65, 97, - 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, - 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, - 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, - 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, - 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, - 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, - 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, - 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, - 5049, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, - 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, - 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, - 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, - 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, - 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, - 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, - 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, - 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, - 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, - 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, - 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, - 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, - 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, - 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, - 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, - 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, - 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, - 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, - 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, - 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, - 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, - 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, - 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, - 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, - 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, - 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, - 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, - 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, - 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, - 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, - 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, - 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, - 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, - 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, - 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, - 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, - 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, - 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, - 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, - 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, - 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, - 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, - 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, - 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, - 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, - 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, - 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, - 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, - 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, - 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, - 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, - 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, - 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, - 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, - 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, - 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, - 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, - 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, - 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, - 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, - 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, - 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, - 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, - 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, - 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, - 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, - 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, - 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, - 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, - 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, - 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, - 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, - 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, - 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, - 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, - 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, - 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, - 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, - 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, - 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, - 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, - 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, - 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, - 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, - 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, - 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, - 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, - 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, - 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, - 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, - 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, - 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, - 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, - 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, - 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, - 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, - 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, - 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, - 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, - 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, - 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, - 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, - 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, - 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, - 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, - 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, - 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, 0, 0, 0, 0, 783, 1, 0, - 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, - 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, - 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, 1, 0, 0, 0, 0, 805, 1, - 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, - 813, 1, 0, 0, 0, 0, 815, 1, 0, 0, 0, 0, 817, 1, 0, 0, 0, 0, 819, 1, 0, - 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, - 1, 0, 0, 0, 0, 829, 1, 0, 0, 0, 0, 831, 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, - 0, 835, 1, 0, 0, 0, 0, 837, 1, 0, 0, 0, 0, 839, 1, 0, 0, 0, 0, 841, 1, - 0, 0, 0, 0, 843, 1, 0, 0, 0, 0, 845, 1, 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, - 849, 1, 0, 0, 0, 0, 851, 1, 0, 0, 0, 0, 853, 1, 0, 0, 0, 0, 855, 1, 0, - 0, 0, 0, 857, 1, 0, 0, 0, 0, 859, 1, 0, 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, - 1, 0, 0, 0, 0, 865, 1, 0, 0, 0, 0, 867, 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, - 0, 871, 1, 0, 0, 0, 0, 873, 1, 0, 0, 0, 0, 875, 1, 0, 0, 0, 0, 877, 1, - 0, 0, 0, 0, 879, 1, 0, 0, 0, 0, 881, 1, 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, - 885, 1, 0, 0, 0, 0, 887, 1, 0, 0, 0, 0, 889, 1, 0, 0, 0, 0, 891, 1, 0, - 0, 0, 0, 893, 1, 0, 0, 0, 0, 895, 1, 0, 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, - 1, 0, 0, 0, 0, 901, 1, 0, 0, 0, 0, 903, 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, - 0, 907, 1, 0, 0, 0, 0, 909, 1, 0, 0, 0, 0, 911, 1, 0, 0, 0, 0, 913, 1, - 0, 0, 0, 0, 915, 1, 0, 0, 0, 0, 917, 1, 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, - 921, 1, 0, 0, 0, 0, 923, 1, 0, 0, 0, 0, 925, 1, 0, 0, 0, 0, 927, 1, 0, - 0, 0, 0, 929, 1, 0, 0, 0, 0, 931, 1, 0, 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, - 1, 0, 0, 0, 0, 937, 1, 0, 0, 0, 0, 939, 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, - 0, 943, 1, 0, 0, 0, 0, 945, 1, 0, 0, 0, 0, 947, 1, 0, 0, 0, 0, 949, 1, - 0, 0, 0, 0, 951, 1, 0, 0, 0, 0, 953, 1, 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, - 957, 1, 0, 0, 0, 0, 959, 1, 0, 0, 0, 0, 961, 1, 0, 0, 0, 0, 963, 1, 0, - 0, 0, 0, 965, 1, 0, 0, 0, 0, 967, 1, 0, 0, 0, 1, 1028, 1, 0, 0, 0, 3, 1034, - 1, 0, 0, 0, 5, 1047, 1, 0, 0, 0, 7, 1061, 1, 0, 0, 0, 9, 1072, 1, 0, 0, - 0, 11, 1092, 1, 0, 0, 0, 13, 1104, 1, 0, 0, 0, 15, 1117, 1, 0, 0, 0, 17, - 1130, 1, 0, 0, 0, 19, 1143, 1, 0, 0, 0, 21, 1155, 1, 0, 0, 0, 23, 1170, - 1, 0, 0, 0, 25, 1186, 1, 0, 0, 0, 27, 1270, 1, 0, 0, 0, 29, 1362, 1, 0, - 0, 0, 31, 1445, 1, 0, 0, 0, 33, 1447, 1, 0, 0, 0, 35, 1454, 1, 0, 0, 0, - 37, 1460, 1, 0, 0, 0, 39, 1465, 1, 0, 0, 0, 41, 1472, 1, 0, 0, 0, 43, 1477, - 1, 0, 0, 0, 45, 1484, 1, 0, 0, 0, 47, 1491, 1, 0, 0, 0, 49, 1502, 1, 0, - 0, 0, 51, 1507, 1, 0, 0, 0, 53, 1516, 1, 0, 0, 0, 55, 1528, 1, 0, 0, 0, - 57, 1540, 1, 0, 0, 0, 59, 1547, 1, 0, 0, 0, 61, 1557, 1, 0, 0, 0, 63, 1566, - 1, 0, 0, 0, 65, 1575, 1, 0, 0, 0, 67, 1580, 1, 0, 0, 0, 69, 1588, 1, 0, - 0, 0, 71, 1595, 1, 0, 0, 0, 73, 1604, 1, 0, 0, 0, 75, 1613, 1, 0, 0, 0, - 77, 1623, 1, 0, 0, 0, 79, 1630, 1, 0, 0, 0, 81, 1638, 1, 0, 0, 0, 83, 1644, - 1, 0, 0, 0, 85, 1650, 1, 0, 0, 0, 87, 1660, 1, 0, 0, 0, 89, 1675, 1, 0, - 0, 0, 91, 1683, 1, 0, 0, 0, 93, 1687, 1, 0, 0, 0, 95, 1691, 1, 0, 0, 0, - 97, 1700, 1, 0, 0, 0, 99, 1714, 1, 0, 0, 0, 101, 1722, 1, 0, 0, 0, 103, - 1728, 1, 0, 0, 0, 105, 1746, 1, 0, 0, 0, 107, 1754, 1, 0, 0, 0, 109, 1762, - 1, 0, 0, 0, 111, 1770, 1, 0, 0, 0, 113, 1781, 1, 0, 0, 0, 115, 1787, 1, - 0, 0, 0, 117, 1795, 1, 0, 0, 0, 119, 1803, 1, 0, 0, 0, 121, 1810, 1, 0, - 0, 0, 123, 1816, 1, 0, 0, 0, 125, 1821, 1, 0, 0, 0, 127, 1826, 1, 0, 0, - 0, 129, 1831, 1, 0, 0, 0, 131, 1840, 1, 0, 0, 0, 133, 1844, 1, 0, 0, 0, - 135, 1855, 1, 0, 0, 0, 137, 1861, 1, 0, 0, 0, 139, 1868, 1, 0, 0, 0, 141, - 1873, 1, 0, 0, 0, 143, 1879, 1, 0, 0, 0, 145, 1886, 1, 0, 0, 0, 147, 1893, - 1, 0, 0, 0, 149, 1899, 1, 0, 0, 0, 151, 1902, 1, 0, 0, 0, 153, 1910, 1, - 0, 0, 0, 155, 1920, 1, 0, 0, 0, 157, 1925, 1, 0, 0, 0, 159, 1930, 1, 0, - 0, 0, 161, 1935, 1, 0, 0, 0, 163, 1940, 1, 0, 0, 0, 165, 1944, 1, 0, 0, - 0, 167, 1953, 1, 0, 0, 0, 169, 1957, 1, 0, 0, 0, 171, 1962, 1, 0, 0, 0, - 173, 1967, 1, 0, 0, 0, 175, 1973, 1, 0, 0, 0, 177, 1979, 1, 0, 0, 0, 179, - 1985, 1, 0, 0, 0, 181, 1990, 1, 0, 0, 0, 183, 1996, 1, 0, 0, 0, 185, 1999, - 1, 0, 0, 0, 187, 2003, 1, 0, 0, 0, 189, 2008, 1, 0, 0, 0, 191, 2014, 1, - 0, 0, 0, 193, 2022, 1, 0, 0, 0, 195, 2029, 1, 0, 0, 0, 197, 2038, 1, 0, - 0, 0, 199, 2045, 1, 0, 0, 0, 201, 2052, 1, 0, 0, 0, 203, 2061, 1, 0, 0, - 0, 205, 2066, 1, 0, 0, 0, 207, 2072, 1, 0, 0, 0, 209, 2075, 1, 0, 0, 0, - 211, 2081, 1, 0, 0, 0, 213, 2088, 1, 0, 0, 0, 215, 2097, 1, 0, 0, 0, 217, - 2103, 1, 0, 0, 0, 219, 2110, 1, 0, 0, 0, 221, 2116, 1, 0, 0, 0, 223, 2120, - 1, 0, 0, 0, 225, 2125, 1, 0, 0, 0, 227, 2130, 1, 0, 0, 0, 229, 2137, 1, - 0, 0, 0, 231, 2145, 1, 0, 0, 0, 233, 2151, 1, 0, 0, 0, 235, 2156, 1, 0, - 0, 0, 237, 2163, 1, 0, 0, 0, 239, 2168, 1, 0, 0, 0, 241, 2173, 1, 0, 0, - 0, 243, 2178, 1, 0, 0, 0, 245, 2183, 1, 0, 0, 0, 247, 2189, 1, 0, 0, 0, - 249, 2199, 1, 0, 0, 0, 251, 2208, 1, 0, 0, 0, 253, 2217, 1, 0, 0, 0, 255, - 2225, 1, 0, 0, 0, 257, 2233, 1, 0, 0, 0, 259, 2241, 1, 0, 0, 0, 261, 2246, - 1, 0, 0, 0, 263, 2253, 1, 0, 0, 0, 265, 2260, 1, 0, 0, 0, 267, 2265, 1, - 0, 0, 0, 269, 2273, 1, 0, 0, 0, 271, 2279, 1, 0, 0, 0, 273, 2288, 1, 0, - 0, 0, 275, 2293, 1, 0, 0, 0, 277, 2299, 1, 0, 0, 0, 279, 2306, 1, 0, 0, - 0, 281, 2314, 1, 0, 0, 0, 283, 2320, 1, 0, 0, 0, 285, 2328, 1, 0, 0, 0, - 287, 2337, 1, 0, 0, 0, 289, 2347, 1, 0, 0, 0, 291, 2359, 1, 0, 0, 0, 293, - 2371, 1, 0, 0, 0, 295, 2382, 1, 0, 0, 0, 297, 2391, 1, 0, 0, 0, 299, 2400, - 1, 0, 0, 0, 301, 2409, 1, 0, 0, 0, 303, 2417, 1, 0, 0, 0, 305, 2427, 1, - 0, 0, 0, 307, 2431, 1, 0, 0, 0, 309, 2436, 1, 0, 0, 0, 311, 2447, 1, 0, - 0, 0, 313, 2454, 1, 0, 0, 0, 315, 2464, 1, 0, 0, 0, 317, 2479, 1, 0, 0, - 0, 319, 2492, 1, 0, 0, 0, 321, 2503, 1, 0, 0, 0, 323, 2510, 1, 0, 0, 0, - 325, 2516, 1, 0, 0, 0, 327, 2528, 1, 0, 0, 0, 329, 2536, 1, 0, 0, 0, 331, - 2547, 1, 0, 0, 0, 333, 2553, 1, 0, 0, 0, 335, 2561, 1, 0, 0, 0, 337, 2570, - 1, 0, 0, 0, 339, 2581, 1, 0, 0, 0, 341, 2594, 1, 0, 0, 0, 343, 2603, 1, - 0, 0, 0, 345, 2612, 1, 0, 0, 0, 347, 2621, 1, 0, 0, 0, 349, 2639, 1, 0, - 0, 0, 351, 2665, 1, 0, 0, 0, 353, 2675, 1, 0, 0, 0, 355, 2686, 1, 0, 0, - 0, 357, 2699, 1, 0, 0, 0, 359, 2710, 1, 0, 0, 0, 361, 2723, 1, 0, 0, 0, - 363, 2738, 1, 0, 0, 0, 365, 2749, 1, 0, 0, 0, 367, 2756, 1, 0, 0, 0, 369, - 2763, 1, 0, 0, 0, 371, 2771, 1, 0, 0, 0, 373, 2779, 1, 0, 0, 0, 375, 2784, - 1, 0, 0, 0, 377, 2792, 1, 0, 0, 0, 379, 2803, 1, 0, 0, 0, 381, 2810, 1, - 0, 0, 0, 383, 2820, 1, 0, 0, 0, 385, 2827, 1, 0, 0, 0, 387, 2834, 1, 0, - 0, 0, 389, 2842, 1, 0, 0, 0, 391, 2853, 1, 0, 0, 0, 393, 2859, 1, 0, 0, - 0, 395, 2864, 1, 0, 0, 0, 397, 2878, 1, 0, 0, 0, 399, 2892, 1, 0, 0, 0, - 401, 2899, 1, 0, 0, 0, 403, 2909, 1, 0, 0, 0, 405, 2922, 1, 0, 0, 0, 407, - 2928, 1, 0, 0, 0, 409, 2934, 1, 0, 0, 0, 411, 2946, 1, 0, 0, 0, 413, 2953, - 1, 0, 0, 0, 415, 2964, 1, 0, 0, 0, 417, 2981, 1, 0, 0, 0, 419, 2989, 1, - 0, 0, 0, 421, 2995, 1, 0, 0, 0, 423, 3001, 1, 0, 0, 0, 425, 3008, 1, 0, - 0, 0, 427, 3017, 1, 0, 0, 0, 429, 3021, 1, 0, 0, 0, 431, 3028, 1, 0, 0, - 0, 433, 3036, 1, 0, 0, 0, 435, 3044, 1, 0, 0, 0, 437, 3053, 1, 0, 0, 0, - 439, 3062, 1, 0, 0, 0, 441, 3073, 1, 0, 0, 0, 443, 3084, 1, 0, 0, 0, 445, - 3090, 1, 0, 0, 0, 447, 3102, 1, 0, 0, 0, 449, 3115, 1, 0, 0, 0, 451, 3131, - 1, 0, 0, 0, 453, 3140, 1, 0, 0, 0, 455, 3148, 1, 0, 0, 0, 457, 3160, 1, - 0, 0, 0, 459, 3173, 1, 0, 0, 0, 461, 3188, 1, 0, 0, 0, 463, 3199, 1, 0, - 0, 0, 465, 3209, 1, 0, 0, 0, 467, 3223, 1, 0, 0, 0, 469, 3237, 1, 0, 0, - 0, 471, 3251, 1, 0, 0, 0, 473, 3266, 1, 0, 0, 0, 475, 3280, 1, 0, 0, 0, - 477, 3290, 1, 0, 0, 0, 479, 3299, 1, 0, 0, 0, 481, 3306, 1, 0, 0, 0, 483, - 3314, 1, 0, 0, 0, 485, 3322, 1, 0, 0, 0, 487, 3329, 1, 0, 0, 0, 489, 3337, - 1, 0, 0, 0, 491, 3342, 1, 0, 0, 0, 493, 3351, 1, 0, 0, 0, 495, 3359, 1, - 0, 0, 0, 497, 3368, 1, 0, 0, 0, 499, 3377, 1, 0, 0, 0, 501, 3380, 1, 0, - 0, 0, 503, 3383, 1, 0, 0, 0, 505, 3386, 1, 0, 0, 0, 507, 3389, 1, 0, 0, - 0, 509, 3392, 1, 0, 0, 0, 511, 3395, 1, 0, 0, 0, 513, 3405, 1, 0, 0, 0, - 515, 3412, 1, 0, 0, 0, 517, 3420, 1, 0, 0, 0, 519, 3425, 1, 0, 0, 0, 521, - 3433, 1, 0, 0, 0, 523, 3441, 1, 0, 0, 0, 525, 3450, 1, 0, 0, 0, 527, 3455, - 1, 0, 0, 0, 529, 3466, 1, 0, 0, 0, 531, 3473, 1, 0, 0, 0, 533, 3486, 1, - 0, 0, 0, 535, 3495, 1, 0, 0, 0, 537, 3501, 1, 0, 0, 0, 539, 3516, 1, 0, - 0, 0, 541, 3521, 1, 0, 0, 0, 543, 3527, 1, 0, 0, 0, 545, 3531, 1, 0, 0, - 0, 547, 3535, 1, 0, 0, 0, 549, 3539, 1, 0, 0, 0, 551, 3543, 1, 0, 0, 0, - 553, 3550, 1, 0, 0, 0, 555, 3555, 1, 0, 0, 0, 557, 3564, 1, 0, 0, 0, 559, - 3569, 1, 0, 0, 0, 561, 3573, 1, 0, 0, 0, 563, 3576, 1, 0, 0, 0, 565, 3580, - 1, 0, 0, 0, 567, 3585, 1, 0, 0, 0, 569, 3588, 1, 0, 0, 0, 571, 3596, 1, - 0, 0, 0, 573, 3601, 1, 0, 0, 0, 575, 3607, 1, 0, 0, 0, 577, 3614, 1, 0, - 0, 0, 579, 3621, 1, 0, 0, 0, 581, 3629, 1, 0, 0, 0, 583, 3634, 1, 0, 0, - 0, 585, 3640, 1, 0, 0, 0, 587, 3651, 1, 0, 0, 0, 589, 3660, 1, 0, 0, 0, - 591, 3665, 1, 0, 0, 0, 593, 3674, 1, 0, 0, 0, 595, 3680, 1, 0, 0, 0, 597, - 3686, 1, 0, 0, 0, 599, 3692, 1, 0, 0, 0, 601, 3698, 1, 0, 0, 0, 603, 3706, - 1, 0, 0, 0, 605, 3717, 1, 0, 0, 0, 607, 3723, 1, 0, 0, 0, 609, 3734, 1, - 0, 0, 0, 611, 3739, 1, 0, 0, 0, 613, 3747, 1, 0, 0, 0, 615, 3756, 1, 0, - 0, 0, 617, 3762, 1, 0, 0, 0, 619, 3767, 1, 0, 0, 0, 621, 3772, 1, 0, 0, - 0, 623, 3787, 1, 0, 0, 0, 625, 3793, 1, 0, 0, 0, 627, 3801, 1, 0, 0, 0, - 629, 3807, 1, 0, 0, 0, 631, 3817, 1, 0, 0, 0, 633, 3824, 1, 0, 0, 0, 635, - 3829, 1, 0, 0, 0, 637, 3837, 1, 0, 0, 0, 639, 3842, 1, 0, 0, 0, 641, 3851, - 1, 0, 0, 0, 643, 3859, 1, 0, 0, 0, 645, 3864, 1, 0, 0, 0, 647, 3868, 1, - 0, 0, 0, 649, 3875, 1, 0, 0, 0, 651, 3883, 1, 0, 0, 0, 653, 3887, 1, 0, - 0, 0, 655, 3892, 1, 0, 0, 0, 657, 3896, 1, 0, 0, 0, 659, 3902, 1, 0, 0, - 0, 661, 3906, 1, 0, 0, 0, 663, 3913, 1, 0, 0, 0, 665, 3921, 1, 0, 0, 0, - 667, 3929, 1, 0, 0, 0, 669, 3936, 1, 0, 0, 0, 671, 3946, 1, 0, 0, 0, 673, - 3954, 1, 0, 0, 0, 675, 3960, 1, 0, 0, 0, 677, 3967, 1, 0, 0, 0, 679, 3981, - 1, 0, 0, 0, 681, 3990, 1, 0, 0, 0, 683, 3999, 1, 0, 0, 0, 685, 4010, 1, - 0, 0, 0, 687, 4019, 1, 0, 0, 0, 689, 4025, 1, 0, 0, 0, 691, 4029, 1, 0, - 0, 0, 693, 4037, 1, 0, 0, 0, 695, 4044, 1, 0, 0, 0, 697, 4049, 1, 0, 0, - 0, 699, 4055, 1, 0, 0, 0, 701, 4060, 1, 0, 0, 0, 703, 4067, 1, 0, 0, 0, - 705, 4076, 1, 0, 0, 0, 707, 4086, 1, 0, 0, 0, 709, 4091, 1, 0, 0, 0, 711, - 4098, 1, 0, 0, 0, 713, 4104, 1, 0, 0, 0, 715, 4112, 1, 0, 0, 0, 717, 4122, - 1, 0, 0, 0, 719, 4133, 1, 0, 0, 0, 721, 4141, 1, 0, 0, 0, 723, 4152, 1, - 0, 0, 0, 725, 4157, 1, 0, 0, 0, 727, 4163, 1, 0, 0, 0, 729, 4168, 1, 0, - 0, 0, 731, 4174, 1, 0, 0, 0, 733, 4180, 1, 0, 0, 0, 735, 4188, 1, 0, 0, - 0, 737, 4197, 1, 0, 0, 0, 739, 4210, 1, 0, 0, 0, 741, 4221, 1, 0, 0, 0, - 743, 4231, 1, 0, 0, 0, 745, 4241, 1, 0, 0, 0, 747, 4254, 1, 0, 0, 0, 749, - 4264, 1, 0, 0, 0, 751, 4276, 1, 0, 0, 0, 753, 4283, 1, 0, 0, 0, 755, 4292, - 1, 0, 0, 0, 757, 4302, 1, 0, 0, 0, 759, 4309, 1, 0, 0, 0, 761, 4316, 1, - 0, 0, 0, 763, 4322, 1, 0, 0, 0, 765, 4329, 1, 0, 0, 0, 767, 4337, 1, 0, - 0, 0, 769, 4343, 1, 0, 0, 0, 771, 4349, 1, 0, 0, 0, 773, 4357, 1, 0, 0, - 0, 775, 4364, 1, 0, 0, 0, 777, 4369, 1, 0, 0, 0, 779, 4375, 1, 0, 0, 0, - 781, 4380, 1, 0, 0, 0, 783, 4386, 1, 0, 0, 0, 785, 4394, 1, 0, 0, 0, 787, - 4402, 1, 0, 0, 0, 789, 4410, 1, 0, 0, 0, 791, 4416, 1, 0, 0, 0, 793, 4427, - 1, 0, 0, 0, 795, 4435, 1, 0, 0, 0, 797, 4443, 1, 0, 0, 0, 799, 4454, 1, - 0, 0, 0, 801, 4465, 1, 0, 0, 0, 803, 4472, 1, 0, 0, 0, 805, 4478, 1, 0, - 0, 0, 807, 4488, 1, 0, 0, 0, 809, 4493, 1, 0, 0, 0, 811, 4499, 1, 0, 0, - 0, 813, 4506, 1, 0, 0, 0, 815, 4515, 1, 0, 0, 0, 817, 4520, 1, 0, 0, 0, - 819, 4525, 1, 0, 0, 0, 821, 4528, 1, 0, 0, 0, 823, 4531, 1, 0, 0, 0, 825, - 4536, 1, 0, 0, 0, 827, 4540, 1, 0, 0, 0, 829, 4548, 1, 0, 0, 0, 831, 4556, - 1, 0, 0, 0, 833, 4570, 1, 0, 0, 0, 835, 4577, 1, 0, 0, 0, 837, 4581, 1, - 0, 0, 0, 839, 4589, 1, 0, 0, 0, 841, 4593, 1, 0, 0, 0, 843, 4597, 1, 0, - 0, 0, 845, 4608, 1, 0, 0, 0, 847, 4611, 1, 0, 0, 0, 849, 4620, 1, 0, 0, - 0, 851, 4626, 1, 0, 0, 0, 853, 4636, 1, 0, 0, 0, 855, 4645, 1, 0, 0, 0, - 857, 4659, 1, 0, 0, 0, 859, 4668, 1, 0, 0, 0, 861, 4673, 1, 0, 0, 0, 863, - 4679, 1, 0, 0, 0, 865, 4685, 1, 0, 0, 0, 867, 4692, 1, 0, 0, 0, 869, 4703, - 1, 0, 0, 0, 871, 4713, 1, 0, 0, 0, 873, 4720, 1, 0, 0, 0, 875, 4725, 1, - 0, 0, 0, 877, 4732, 1, 0, 0, 0, 879, 4738, 1, 0, 0, 0, 881, 4745, 1, 0, - 0, 0, 883, 4751, 1, 0, 0, 0, 885, 4756, 1, 0, 0, 0, 887, 4761, 1, 0, 0, - 0, 889, 4767, 1, 0, 0, 0, 891, 4779, 1, 0, 0, 0, 893, 4783, 1, 0, 0, 0, - 895, 4793, 1, 0, 0, 0, 897, 4795, 1, 0, 0, 0, 899, 4798, 1, 0, 0, 0, 901, - 4801, 1, 0, 0, 0, 903, 4803, 1, 0, 0, 0, 905, 4805, 1, 0, 0, 0, 907, 4807, - 1, 0, 0, 0, 909, 4809, 1, 0, 0, 0, 911, 4811, 1, 0, 0, 0, 913, 4813, 1, - 0, 0, 0, 915, 4815, 1, 0, 0, 0, 917, 4817, 1, 0, 0, 0, 919, 4821, 1, 0, - 0, 0, 921, 4825, 1, 0, 0, 0, 923, 4827, 1, 0, 0, 0, 925, 4829, 1, 0, 0, - 0, 927, 4831, 1, 0, 0, 0, 929, 4833, 1, 0, 0, 0, 931, 4835, 1, 0, 0, 0, - 933, 4837, 1, 0, 0, 0, 935, 4839, 1, 0, 0, 0, 937, 4841, 1, 0, 0, 0, 939, - 4843, 1, 0, 0, 0, 941, 4845, 1, 0, 0, 0, 943, 4847, 1, 0, 0, 0, 945, 4849, - 1, 0, 0, 0, 947, 4852, 1, 0, 0, 0, 949, 4855, 1, 0, 0, 0, 951, 4857, 1, - 0, 0, 0, 953, 4859, 1, 0, 0, 0, 955, 4871, 1, 0, 0, 0, 957, 4884, 1, 0, - 0, 0, 959, 4897, 1, 0, 0, 0, 961, 4923, 1, 0, 0, 0, 963, 4929, 1, 0, 0, - 0, 965, 4936, 1, 0, 0, 0, 967, 4970, 1, 0, 0, 0, 969, 4972, 1, 0, 0, 0, - 971, 4974, 1, 0, 0, 0, 973, 4976, 1, 0, 0, 0, 975, 4978, 1, 0, 0, 0, 977, - 4980, 1, 0, 0, 0, 979, 4982, 1, 0, 0, 0, 981, 4984, 1, 0, 0, 0, 983, 4986, - 1, 0, 0, 0, 985, 4988, 1, 0, 0, 0, 987, 4990, 1, 0, 0, 0, 989, 4992, 1, - 0, 0, 0, 991, 4994, 1, 0, 0, 0, 993, 4996, 1, 0, 0, 0, 995, 4998, 1, 0, - 0, 0, 997, 5000, 1, 0, 0, 0, 999, 5002, 1, 0, 0, 0, 1001, 5004, 1, 0, 0, - 0, 1003, 5006, 1, 0, 0, 0, 1005, 5008, 1, 0, 0, 0, 1007, 5010, 1, 0, 0, - 0, 1009, 5012, 1, 0, 0, 0, 1011, 5014, 1, 0, 0, 0, 1013, 5016, 1, 0, 0, - 0, 1015, 5018, 1, 0, 0, 0, 1017, 5020, 1, 0, 0, 0, 1019, 5022, 1, 0, 0, - 0, 1021, 5024, 1, 0, 0, 0, 1023, 5026, 1, 0, 0, 0, 1025, 5028, 1, 0, 0, - 0, 1027, 1029, 7, 0, 0, 0, 1028, 1027, 1, 0, 0, 0, 1029, 1030, 1, 0, 0, - 0, 1030, 1028, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, - 0, 1032, 1033, 6, 0, 0, 0, 1033, 2, 1, 0, 0, 0, 1034, 1035, 5, 47, 0, 0, - 1035, 1036, 5, 42, 0, 0, 1036, 1037, 5, 42, 0, 0, 1037, 1041, 1, 0, 0, - 0, 1038, 1040, 9, 0, 0, 0, 1039, 1038, 1, 0, 0, 0, 1040, 1043, 1, 0, 0, - 0, 1041, 1042, 1, 0, 0, 0, 1041, 1039, 1, 0, 0, 0, 1042, 1044, 1, 0, 0, - 0, 1043, 1041, 1, 0, 0, 0, 1044, 1045, 5, 42, 0, 0, 1045, 1046, 5, 47, - 0, 0, 1046, 4, 1, 0, 0, 0, 1047, 1048, 5, 47, 0, 0, 1048, 1049, 5, 42, - 0, 0, 1049, 1053, 1, 0, 0, 0, 1050, 1052, 9, 0, 0, 0, 1051, 1050, 1, 0, - 0, 0, 1052, 1055, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1053, 1051, 1, 0, - 0, 0, 1054, 1056, 1, 0, 0, 0, 1055, 1053, 1, 0, 0, 0, 1056, 1057, 5, 42, - 0, 0, 1057, 1058, 5, 47, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1060, 6, 2, - 0, 0, 1060, 6, 1, 0, 0, 0, 1061, 1062, 5, 45, 0, 0, 1062, 1063, 5, 45, - 0, 0, 1063, 1067, 1, 0, 0, 0, 1064, 1066, 8, 1, 0, 0, 1065, 1064, 1, 0, - 0, 0, 1066, 1069, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1067, 1068, 1, 0, - 0, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1071, 6, 3, - 0, 0, 1071, 8, 1, 0, 0, 0, 1072, 1073, 3, 991, 495, 0, 1073, 1075, 3, 1011, - 505, 0, 1074, 1076, 3, 1, 0, 0, 1075, 1074, 1, 0, 0, 0, 1076, 1077, 1, - 0, 0, 0, 1077, 1075, 1, 0, 0, 0, 1077, 1078, 1, 0, 0, 0, 1078, 1079, 1, - 0, 0, 0, 1079, 1080, 3, 1001, 500, 0, 1080, 1081, 3, 1003, 501, 0, 1081, - 1083, 3, 1013, 506, 0, 1082, 1084, 3, 1, 0, 0, 1083, 1082, 1, 0, 0, 0, - 1084, 1085, 1, 0, 0, 0, 1085, 1083, 1, 0, 0, 0, 1085, 1086, 1, 0, 0, 0, - 1086, 1087, 1, 0, 0, 0, 1087, 1088, 3, 1001, 500, 0, 1088, 1089, 3, 1015, - 507, 0, 1089, 1090, 3, 997, 498, 0, 1090, 1091, 3, 997, 498, 0, 1091, 10, - 1, 0, 0, 0, 1092, 1093, 3, 991, 495, 0, 1093, 1095, 3, 1011, 505, 0, 1094, - 1096, 3, 1, 0, 0, 1095, 1094, 1, 0, 0, 0, 1096, 1097, 1, 0, 0, 0, 1097, - 1095, 1, 0, 0, 0, 1097, 1098, 1, 0, 0, 0, 1098, 1099, 1, 0, 0, 0, 1099, - 1100, 3, 1001, 500, 0, 1100, 1101, 3, 1015, 507, 0, 1101, 1102, 3, 997, - 498, 0, 1102, 1103, 3, 997, 498, 0, 1103, 12, 1, 0, 0, 0, 1104, 1105, 3, - 1001, 500, 0, 1105, 1106, 3, 1003, 501, 0, 1106, 1108, 3, 1013, 506, 0, - 1107, 1109, 3, 1, 0, 0, 1108, 1107, 1, 0, 0, 0, 1109, 1110, 1, 0, 0, 0, - 1110, 1108, 1, 0, 0, 0, 1110, 1111, 1, 0, 0, 0, 1111, 1112, 1, 0, 0, 0, - 1112, 1113, 3, 1001, 500, 0, 1113, 1114, 3, 1015, 507, 0, 1114, 1115, 3, - 997, 498, 0, 1115, 1116, 3, 997, 498, 0, 1116, 14, 1, 0, 0, 0, 1117, 1118, - 3, 987, 493, 0, 1118, 1119, 3, 1009, 504, 0, 1119, 1120, 3, 1003, 501, - 0, 1120, 1121, 3, 1015, 507, 0, 1121, 1123, 3, 1005, 502, 0, 1122, 1124, - 3, 1, 0, 0, 1123, 1122, 1, 0, 0, 0, 1124, 1125, 1, 0, 0, 0, 1125, 1123, - 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1128, - 3, 977, 488, 0, 1128, 1129, 3, 1023, 511, 0, 1129, 16, 1, 0, 0, 0, 1130, - 1131, 3, 1003, 501, 0, 1131, 1132, 3, 1009, 504, 0, 1132, 1133, 3, 981, - 490, 0, 1133, 1134, 3, 983, 491, 0, 1134, 1136, 3, 1009, 504, 0, 1135, - 1137, 3, 1, 0, 0, 1136, 1135, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, - 1136, 1, 0, 0, 0, 1138, 1139, 1, 0, 0, 0, 1139, 1140, 1, 0, 0, 0, 1140, - 1141, 3, 977, 488, 0, 1141, 1142, 3, 1023, 511, 0, 1142, 18, 1, 0, 0, 0, - 1143, 1144, 3, 1011, 505, 0, 1144, 1145, 3, 1003, 501, 0, 1145, 1146, 3, - 1009, 504, 0, 1146, 1148, 3, 1013, 506, 0, 1147, 1149, 3, 1, 0, 0, 1148, - 1147, 1, 0, 0, 0, 1149, 1150, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1150, - 1151, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1153, 3, 977, 488, 0, 1153, - 1154, 3, 1023, 511, 0, 1154, 20, 1, 0, 0, 0, 1155, 1156, 3, 1001, 500, - 0, 1156, 1157, 3, 1003, 501, 0, 1157, 1158, 3, 1001, 500, 0, 1158, 1159, - 5, 45, 0, 0, 1159, 1160, 3, 1005, 502, 0, 1160, 1161, 3, 983, 491, 0, 1161, - 1162, 3, 1009, 504, 0, 1162, 1163, 3, 1011, 505, 0, 1163, 1164, 3, 991, - 495, 0, 1164, 1165, 3, 1011, 505, 0, 1165, 1166, 3, 1013, 506, 0, 1166, - 1167, 3, 983, 491, 0, 1167, 1168, 3, 1001, 500, 0, 1168, 1169, 3, 1013, - 506, 0, 1169, 22, 1, 0, 0, 0, 1170, 1171, 3, 1009, 504, 0, 1171, 1172, - 3, 983, 491, 0, 1172, 1173, 3, 985, 492, 0, 1173, 1174, 3, 983, 491, 0, - 1174, 1175, 3, 1009, 504, 0, 1175, 1176, 3, 983, 491, 0, 1176, 1177, 3, - 1001, 500, 0, 1177, 1178, 3, 979, 489, 0, 1178, 1180, 3, 983, 491, 0, 1179, - 1181, 5, 95, 0, 0, 1180, 1179, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, - 1182, 1, 0, 0, 0, 1182, 1183, 3, 1011, 505, 0, 1183, 1184, 3, 983, 491, - 0, 1184, 1185, 3, 1013, 506, 0, 1185, 24, 1, 0, 0, 0, 1186, 1187, 3, 997, - 498, 0, 1187, 1188, 3, 991, 495, 0, 1188, 1189, 3, 1011, 505, 0, 1189, - 1191, 3, 1013, 506, 0, 1190, 1192, 3, 1, 0, 0, 1191, 1190, 1, 0, 0, 0, - 1192, 1193, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, - 1194, 1195, 1, 0, 0, 0, 1195, 1196, 3, 1003, 501, 0, 1196, 1197, 3, 985, - 492, 0, 1197, 26, 1, 0, 0, 0, 1198, 1199, 3, 981, 490, 0, 1199, 1200, 3, - 983, 491, 0, 1200, 1201, 3, 997, 498, 0, 1201, 1202, 3, 983, 491, 0, 1202, - 1203, 3, 1013, 506, 0, 1203, 1205, 3, 983, 491, 0, 1204, 1206, 3, 1, 0, - 0, 1205, 1204, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 1205, 1, 0, 0, - 0, 1207, 1208, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 1210, 3, 975, - 487, 0, 1210, 1211, 3, 1001, 500, 0, 1211, 1213, 3, 981, 490, 0, 1212, - 1214, 3, 1, 0, 0, 1213, 1212, 1, 0, 0, 0, 1214, 1215, 1, 0, 0, 0, 1215, - 1213, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, - 1218, 3, 1009, 504, 0, 1218, 1219, 3, 983, 491, 0, 1219, 1220, 3, 985, - 492, 0, 1220, 1221, 3, 983, 491, 0, 1221, 1222, 3, 1009, 504, 0, 1222, - 1223, 3, 983, 491, 0, 1223, 1224, 3, 1001, 500, 0, 1224, 1225, 3, 979, - 489, 0, 1225, 1226, 3, 983, 491, 0, 1226, 1227, 3, 1011, 505, 0, 1227, - 1271, 1, 0, 0, 0, 1228, 1229, 3, 981, 490, 0, 1229, 1230, 3, 983, 491, - 0, 1230, 1231, 3, 997, 498, 0, 1231, 1232, 3, 983, 491, 0, 1232, 1233, - 3, 1013, 506, 0, 1233, 1234, 3, 983, 491, 0, 1234, 1235, 5, 95, 0, 0, 1235, - 1236, 3, 975, 487, 0, 1236, 1237, 3, 1001, 500, 0, 1237, 1238, 3, 981, - 490, 0, 1238, 1239, 5, 95, 0, 0, 1239, 1240, 3, 1009, 504, 0, 1240, 1241, - 3, 983, 491, 0, 1241, 1242, 3, 985, 492, 0, 1242, 1243, 3, 983, 491, 0, - 1243, 1244, 3, 1009, 504, 0, 1244, 1245, 3, 983, 491, 0, 1245, 1246, 3, - 1001, 500, 0, 1246, 1247, 3, 979, 489, 0, 1247, 1248, 3, 983, 491, 0, 1248, - 1249, 3, 1011, 505, 0, 1249, 1271, 1, 0, 0, 0, 1250, 1251, 3, 981, 490, - 0, 1251, 1252, 3, 983, 491, 0, 1252, 1253, 3, 997, 498, 0, 1253, 1254, - 3, 983, 491, 0, 1254, 1255, 3, 1013, 506, 0, 1255, 1256, 3, 983, 491, 0, - 1256, 1257, 3, 975, 487, 0, 1257, 1258, 3, 1001, 500, 0, 1258, 1259, 3, - 981, 490, 0, 1259, 1260, 3, 1009, 504, 0, 1260, 1261, 3, 983, 491, 0, 1261, - 1262, 3, 985, 492, 0, 1262, 1263, 3, 983, 491, 0, 1263, 1264, 3, 1009, - 504, 0, 1264, 1265, 3, 983, 491, 0, 1265, 1266, 3, 1001, 500, 0, 1266, - 1267, 3, 979, 489, 0, 1267, 1268, 3, 983, 491, 0, 1268, 1269, 3, 1011, - 505, 0, 1269, 1271, 1, 0, 0, 0, 1270, 1198, 1, 0, 0, 0, 1270, 1228, 1, - 0, 0, 0, 1270, 1250, 1, 0, 0, 0, 1271, 28, 1, 0, 0, 0, 1272, 1273, 3, 981, - 490, 0, 1273, 1274, 3, 983, 491, 0, 1274, 1275, 3, 997, 498, 0, 1275, 1276, - 3, 983, 491, 0, 1276, 1277, 3, 1013, 506, 0, 1277, 1279, 3, 983, 491, 0, - 1278, 1280, 3, 1, 0, 0, 1279, 1278, 1, 0, 0, 0, 1280, 1281, 1, 0, 0, 0, - 1281, 1279, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1283, 1, 0, 0, 0, - 1283, 1284, 3, 977, 488, 0, 1284, 1285, 3, 1015, 507, 0, 1285, 1287, 3, - 1013, 506, 0, 1286, 1288, 3, 1, 0, 0, 1287, 1286, 1, 0, 0, 0, 1288, 1289, - 1, 0, 0, 0, 1289, 1287, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, 1291, - 1, 0, 0, 0, 1291, 1292, 3, 995, 497, 0, 1292, 1293, 3, 983, 491, 0, 1293, - 1294, 3, 983, 491, 0, 1294, 1296, 3, 1005, 502, 0, 1295, 1297, 3, 1, 0, - 0, 1296, 1295, 1, 0, 0, 0, 1297, 1298, 1, 0, 0, 0, 1298, 1296, 1, 0, 0, - 0, 1298, 1299, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1301, 3, 1009, - 504, 0, 1301, 1302, 3, 983, 491, 0, 1302, 1303, 3, 985, 492, 0, 1303, 1304, - 3, 983, 491, 0, 1304, 1305, 3, 1009, 504, 0, 1305, 1306, 3, 983, 491, 0, - 1306, 1307, 3, 1001, 500, 0, 1307, 1308, 3, 979, 489, 0, 1308, 1309, 3, - 983, 491, 0, 1309, 1310, 3, 1011, 505, 0, 1310, 1363, 1, 0, 0, 0, 1311, - 1312, 3, 981, 490, 0, 1312, 1313, 3, 983, 491, 0, 1313, 1314, 3, 997, 498, - 0, 1314, 1315, 3, 983, 491, 0, 1315, 1316, 3, 1013, 506, 0, 1316, 1317, - 3, 983, 491, 0, 1317, 1318, 5, 95, 0, 0, 1318, 1319, 3, 977, 488, 0, 1319, - 1320, 3, 1015, 507, 0, 1320, 1321, 3, 1013, 506, 0, 1321, 1322, 5, 95, - 0, 0, 1322, 1323, 3, 995, 497, 0, 1323, 1324, 3, 983, 491, 0, 1324, 1325, - 3, 983, 491, 0, 1325, 1326, 3, 1005, 502, 0, 1326, 1327, 5, 95, 0, 0, 1327, - 1328, 3, 1009, 504, 0, 1328, 1329, 3, 983, 491, 0, 1329, 1330, 3, 985, - 492, 0, 1330, 1331, 3, 983, 491, 0, 1331, 1332, 3, 1009, 504, 0, 1332, - 1333, 3, 983, 491, 0, 1333, 1334, 3, 1001, 500, 0, 1334, 1335, 3, 979, - 489, 0, 1335, 1336, 3, 983, 491, 0, 1336, 1337, 3, 1011, 505, 0, 1337, - 1363, 1, 0, 0, 0, 1338, 1339, 3, 981, 490, 0, 1339, 1340, 3, 983, 491, - 0, 1340, 1341, 3, 997, 498, 0, 1341, 1342, 3, 983, 491, 0, 1342, 1343, - 3, 1013, 506, 0, 1343, 1344, 3, 983, 491, 0, 1344, 1345, 3, 977, 488, 0, - 1345, 1346, 3, 1015, 507, 0, 1346, 1347, 3, 1013, 506, 0, 1347, 1348, 3, - 995, 497, 0, 1348, 1349, 3, 983, 491, 0, 1349, 1350, 3, 983, 491, 0, 1350, - 1351, 3, 1005, 502, 0, 1351, 1352, 3, 1009, 504, 0, 1352, 1353, 3, 983, - 491, 0, 1353, 1354, 3, 985, 492, 0, 1354, 1355, 3, 983, 491, 0, 1355, 1356, - 3, 1009, 504, 0, 1356, 1357, 3, 983, 491, 0, 1357, 1358, 3, 1001, 500, - 0, 1358, 1359, 3, 979, 489, 0, 1359, 1360, 3, 983, 491, 0, 1360, 1361, - 3, 1011, 505, 0, 1361, 1363, 1, 0, 0, 0, 1362, 1272, 1, 0, 0, 0, 1362, - 1311, 1, 0, 0, 0, 1362, 1338, 1, 0, 0, 0, 1363, 30, 1, 0, 0, 0, 1364, 1365, - 3, 981, 490, 0, 1365, 1366, 3, 983, 491, 0, 1366, 1367, 3, 997, 498, 0, - 1367, 1368, 3, 983, 491, 0, 1368, 1369, 3, 1013, 506, 0, 1369, 1371, 3, - 983, 491, 0, 1370, 1372, 3, 1, 0, 0, 1371, 1370, 1, 0, 0, 0, 1372, 1373, - 1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1373, 1374, 1, 0, 0, 0, 1374, 1375, - 1, 0, 0, 0, 1375, 1376, 3, 991, 495, 0, 1376, 1378, 3, 985, 492, 0, 1377, - 1379, 3, 1, 0, 0, 1378, 1377, 1, 0, 0, 0, 1379, 1380, 1, 0, 0, 0, 1380, - 1378, 1, 0, 0, 0, 1380, 1381, 1, 0, 0, 0, 1381, 1382, 1, 0, 0, 0, 1382, - 1383, 3, 1001, 500, 0, 1383, 1385, 3, 1003, 501, 0, 1384, 1386, 3, 1, 0, - 0, 1385, 1384, 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1385, 1, 0, 0, - 0, 1387, 1388, 1, 0, 0, 0, 1388, 1389, 1, 0, 0, 0, 1389, 1390, 3, 1009, - 504, 0, 1390, 1391, 3, 983, 491, 0, 1391, 1392, 3, 985, 492, 0, 1392, 1393, - 3, 983, 491, 0, 1393, 1394, 3, 1009, 504, 0, 1394, 1395, 3, 983, 491, 0, - 1395, 1396, 3, 1001, 500, 0, 1396, 1397, 3, 979, 489, 0, 1397, 1398, 3, - 983, 491, 0, 1398, 1399, 3, 1011, 505, 0, 1399, 1446, 1, 0, 0, 0, 1400, - 1401, 3, 981, 490, 0, 1401, 1402, 3, 983, 491, 0, 1402, 1403, 3, 997, 498, - 0, 1403, 1404, 3, 983, 491, 0, 1404, 1405, 3, 1013, 506, 0, 1405, 1406, - 3, 983, 491, 0, 1406, 1407, 5, 95, 0, 0, 1407, 1408, 3, 991, 495, 0, 1408, - 1409, 3, 985, 492, 0, 1409, 1410, 5, 95, 0, 0, 1410, 1411, 3, 1001, 500, - 0, 1411, 1412, 3, 1003, 501, 0, 1412, 1413, 5, 95, 0, 0, 1413, 1414, 3, - 1009, 504, 0, 1414, 1415, 3, 983, 491, 0, 1415, 1416, 3, 985, 492, 0, 1416, - 1417, 3, 983, 491, 0, 1417, 1418, 3, 1009, 504, 0, 1418, 1419, 3, 983, - 491, 0, 1419, 1420, 3, 1001, 500, 0, 1420, 1421, 3, 979, 489, 0, 1421, - 1422, 3, 983, 491, 0, 1422, 1423, 3, 1011, 505, 0, 1423, 1446, 1, 0, 0, - 0, 1424, 1425, 3, 981, 490, 0, 1425, 1426, 3, 983, 491, 0, 1426, 1427, - 3, 997, 498, 0, 1427, 1428, 3, 983, 491, 0, 1428, 1429, 3, 1013, 506, 0, - 1429, 1430, 3, 983, 491, 0, 1430, 1431, 3, 991, 495, 0, 1431, 1432, 3, - 985, 492, 0, 1432, 1433, 3, 1001, 500, 0, 1433, 1434, 3, 1003, 501, 0, - 1434, 1435, 3, 1009, 504, 0, 1435, 1436, 3, 983, 491, 0, 1436, 1437, 3, - 985, 492, 0, 1437, 1438, 3, 983, 491, 0, 1438, 1439, 3, 1009, 504, 0, 1439, - 1440, 3, 983, 491, 0, 1440, 1441, 3, 1001, 500, 0, 1441, 1442, 3, 979, - 489, 0, 1442, 1443, 3, 983, 491, 0, 1443, 1444, 3, 1011, 505, 0, 1444, - 1446, 1, 0, 0, 0, 1445, 1364, 1, 0, 0, 0, 1445, 1400, 1, 0, 0, 0, 1445, - 1424, 1, 0, 0, 0, 1446, 32, 1, 0, 0, 0, 1447, 1448, 3, 979, 489, 0, 1448, - 1449, 3, 1009, 504, 0, 1449, 1450, 3, 983, 491, 0, 1450, 1451, 3, 975, - 487, 0, 1451, 1452, 3, 1013, 506, 0, 1452, 1453, 3, 983, 491, 0, 1453, - 34, 1, 0, 0, 0, 1454, 1455, 3, 975, 487, 0, 1455, 1456, 3, 997, 498, 0, - 1456, 1457, 3, 1013, 506, 0, 1457, 1458, 3, 983, 491, 0, 1458, 1459, 3, - 1009, 504, 0, 1459, 36, 1, 0, 0, 0, 1460, 1461, 3, 981, 490, 0, 1461, 1462, - 3, 1009, 504, 0, 1462, 1463, 3, 1003, 501, 0, 1463, 1464, 3, 1005, 502, - 0, 1464, 38, 1, 0, 0, 0, 1465, 1466, 3, 1009, 504, 0, 1466, 1467, 3, 983, - 491, 0, 1467, 1468, 3, 1001, 500, 0, 1468, 1469, 3, 975, 487, 0, 1469, - 1470, 3, 999, 499, 0, 1470, 1471, 3, 983, 491, 0, 1471, 40, 1, 0, 0, 0, - 1472, 1473, 3, 999, 499, 0, 1473, 1474, 3, 1003, 501, 0, 1474, 1475, 3, - 1017, 508, 0, 1475, 1476, 3, 983, 491, 0, 1476, 42, 1, 0, 0, 0, 1477, 1478, - 3, 999, 499, 0, 1478, 1479, 3, 1003, 501, 0, 1479, 1480, 3, 981, 490, 0, - 1480, 1481, 3, 991, 495, 0, 1481, 1482, 3, 985, 492, 0, 1482, 1483, 3, - 1023, 511, 0, 1483, 44, 1, 0, 0, 0, 1484, 1485, 3, 983, 491, 0, 1485, 1486, - 3, 1001, 500, 0, 1486, 1487, 3, 1013, 506, 0, 1487, 1488, 3, 991, 495, - 0, 1488, 1489, 3, 1013, 506, 0, 1489, 1490, 3, 1023, 511, 0, 1490, 46, - 1, 0, 0, 0, 1491, 1492, 3, 1005, 502, 0, 1492, 1493, 3, 983, 491, 0, 1493, - 1494, 3, 1009, 504, 0, 1494, 1495, 3, 1011, 505, 0, 1495, 1496, 3, 991, - 495, 0, 1496, 1497, 3, 1011, 505, 0, 1497, 1498, 3, 1013, 506, 0, 1498, - 1499, 3, 983, 491, 0, 1499, 1500, 3, 1001, 500, 0, 1500, 1501, 3, 1013, - 506, 0, 1501, 48, 1, 0, 0, 0, 1502, 1503, 3, 1017, 508, 0, 1503, 1504, - 3, 991, 495, 0, 1504, 1505, 3, 983, 491, 0, 1505, 1506, 3, 1019, 509, 0, - 1506, 50, 1, 0, 0, 0, 1507, 1508, 3, 983, 491, 0, 1508, 1509, 3, 1021, - 510, 0, 1509, 1510, 3, 1013, 506, 0, 1510, 1511, 3, 983, 491, 0, 1511, - 1512, 3, 1009, 504, 0, 1512, 1513, 3, 1001, 500, 0, 1513, 1514, 3, 975, - 487, 0, 1514, 1515, 3, 997, 498, 0, 1515, 52, 1, 0, 0, 0, 1516, 1517, 3, - 975, 487, 0, 1517, 1518, 3, 1011, 505, 0, 1518, 1519, 3, 1011, 505, 0, - 1519, 1520, 3, 1003, 501, 0, 1520, 1521, 3, 979, 489, 0, 1521, 1522, 3, - 991, 495, 0, 1522, 1523, 3, 975, 487, 0, 1523, 1524, 3, 1013, 506, 0, 1524, - 1525, 3, 991, 495, 0, 1525, 1526, 3, 1003, 501, 0, 1526, 1527, 3, 1001, - 500, 0, 1527, 54, 1, 0, 0, 0, 1528, 1529, 3, 983, 491, 0, 1529, 1530, 3, - 1001, 500, 0, 1530, 1531, 3, 1015, 507, 0, 1531, 1532, 3, 999, 499, 0, - 1532, 1533, 3, 983, 491, 0, 1533, 1534, 3, 1009, 504, 0, 1534, 1535, 3, - 975, 487, 0, 1535, 1536, 3, 1013, 506, 0, 1536, 1537, 3, 991, 495, 0, 1537, - 1538, 3, 1003, 501, 0, 1538, 1539, 3, 1001, 500, 0, 1539, 56, 1, 0, 0, - 0, 1540, 1541, 3, 999, 499, 0, 1541, 1542, 3, 1003, 501, 0, 1542, 1543, - 3, 981, 490, 0, 1543, 1544, 3, 1015, 507, 0, 1544, 1545, 3, 997, 498, 0, - 1545, 1546, 3, 983, 491, 0, 1546, 58, 1, 0, 0, 0, 1547, 1548, 3, 999, 499, - 0, 1548, 1549, 3, 991, 495, 0, 1549, 1550, 3, 979, 489, 0, 1550, 1551, - 3, 1009, 504, 0, 1551, 1552, 3, 1003, 501, 0, 1552, 1553, 3, 985, 492, - 0, 1553, 1554, 3, 997, 498, 0, 1554, 1555, 3, 1003, 501, 0, 1555, 1556, - 3, 1019, 509, 0, 1556, 60, 1, 0, 0, 0, 1557, 1558, 3, 1001, 500, 0, 1558, - 1559, 3, 975, 487, 0, 1559, 1560, 3, 1001, 500, 0, 1560, 1561, 3, 1003, - 501, 0, 1561, 1562, 3, 985, 492, 0, 1562, 1563, 3, 997, 498, 0, 1563, 1564, - 3, 1003, 501, 0, 1564, 1565, 3, 1019, 509, 0, 1565, 62, 1, 0, 0, 0, 1566, - 1567, 3, 1019, 509, 0, 1567, 1568, 3, 1003, 501, 0, 1568, 1569, 3, 1009, - 504, 0, 1569, 1570, 3, 995, 497, 0, 1570, 1571, 3, 985, 492, 0, 1571, 1572, - 3, 997, 498, 0, 1572, 1573, 3, 1003, 501, 0, 1573, 1574, 3, 1019, 509, - 0, 1574, 64, 1, 0, 0, 0, 1575, 1576, 3, 1005, 502, 0, 1576, 1577, 3, 975, - 487, 0, 1577, 1578, 3, 987, 493, 0, 1578, 1579, 3, 983, 491, 0, 1579, 66, - 1, 0, 0, 0, 1580, 1581, 3, 1011, 505, 0, 1581, 1582, 3, 1001, 500, 0, 1582, - 1583, 3, 991, 495, 0, 1583, 1584, 3, 1005, 502, 0, 1584, 1585, 3, 1005, - 502, 0, 1585, 1586, 3, 983, 491, 0, 1586, 1587, 3, 1013, 506, 0, 1587, - 68, 1, 0, 0, 0, 1588, 1589, 3, 997, 498, 0, 1589, 1590, 3, 975, 487, 0, - 1590, 1591, 3, 1023, 511, 0, 1591, 1592, 3, 1003, 501, 0, 1592, 1593, 3, - 1015, 507, 0, 1593, 1594, 3, 1013, 506, 0, 1594, 70, 1, 0, 0, 0, 1595, - 1596, 3, 1001, 500, 0, 1596, 1597, 3, 1003, 501, 0, 1597, 1598, 3, 1013, - 506, 0, 1598, 1599, 3, 983, 491, 0, 1599, 1600, 3, 977, 488, 0, 1600, 1601, - 3, 1003, 501, 0, 1601, 1602, 3, 1003, 501, 0, 1602, 1603, 3, 995, 497, - 0, 1603, 72, 1, 0, 0, 0, 1604, 1605, 3, 979, 489, 0, 1605, 1606, 3, 1003, - 501, 0, 1606, 1607, 3, 1001, 500, 0, 1607, 1608, 3, 1011, 505, 0, 1608, - 1609, 3, 1013, 506, 0, 1609, 1610, 3, 975, 487, 0, 1610, 1611, 3, 1001, - 500, 0, 1611, 1612, 3, 1013, 506, 0, 1612, 74, 1, 0, 0, 0, 1613, 1614, - 3, 975, 487, 0, 1614, 1615, 3, 1013, 506, 0, 1615, 1616, 3, 1013, 506, - 0, 1616, 1617, 3, 1009, 504, 0, 1617, 1618, 3, 991, 495, 0, 1618, 1619, - 3, 977, 488, 0, 1619, 1620, 3, 1015, 507, 0, 1620, 1621, 3, 1013, 506, - 0, 1621, 1622, 3, 983, 491, 0, 1622, 76, 1, 0, 0, 0, 1623, 1624, 3, 979, - 489, 0, 1624, 1625, 3, 1003, 501, 0, 1625, 1626, 3, 997, 498, 0, 1626, - 1627, 3, 1015, 507, 0, 1627, 1628, 3, 999, 499, 0, 1628, 1629, 3, 1001, - 500, 0, 1629, 78, 1, 0, 0, 0, 1630, 1631, 3, 979, 489, 0, 1631, 1632, 3, - 1003, 501, 0, 1632, 1633, 3, 997, 498, 0, 1633, 1634, 3, 1015, 507, 0, - 1634, 1635, 3, 999, 499, 0, 1635, 1636, 3, 1001, 500, 0, 1636, 1637, 3, - 1011, 505, 0, 1637, 80, 1, 0, 0, 0, 1638, 1639, 3, 991, 495, 0, 1639, 1640, - 3, 1001, 500, 0, 1640, 1641, 3, 981, 490, 0, 1641, 1642, 3, 983, 491, 0, - 1642, 1643, 3, 1021, 510, 0, 1643, 82, 1, 0, 0, 0, 1644, 1645, 3, 1003, - 501, 0, 1645, 1646, 3, 1019, 509, 0, 1646, 1647, 3, 1001, 500, 0, 1647, - 1648, 3, 983, 491, 0, 1648, 1649, 3, 1009, 504, 0, 1649, 84, 1, 0, 0, 0, - 1650, 1651, 3, 1009, 504, 0, 1651, 1652, 3, 983, 491, 0, 1652, 1653, 3, - 985, 492, 0, 1653, 1654, 3, 983, 491, 0, 1654, 1655, 3, 1009, 504, 0, 1655, - 1656, 3, 983, 491, 0, 1656, 1657, 3, 1001, 500, 0, 1657, 1658, 3, 979, - 489, 0, 1658, 1659, 3, 983, 491, 0, 1659, 86, 1, 0, 0, 0, 1660, 1661, 3, - 987, 493, 0, 1661, 1662, 3, 983, 491, 0, 1662, 1663, 3, 1001, 500, 0, 1663, - 1664, 3, 983, 491, 0, 1664, 1665, 3, 1009, 504, 0, 1665, 1666, 3, 975, - 487, 0, 1666, 1667, 3, 997, 498, 0, 1667, 1668, 3, 991, 495, 0, 1668, 1669, - 3, 1025, 512, 0, 1669, 1670, 3, 975, 487, 0, 1670, 1671, 3, 1013, 506, - 0, 1671, 1672, 3, 991, 495, 0, 1672, 1673, 3, 1003, 501, 0, 1673, 1674, - 3, 1001, 500, 0, 1674, 88, 1, 0, 0, 0, 1675, 1676, 3, 983, 491, 0, 1676, - 1677, 3, 1021, 510, 0, 1677, 1678, 3, 1013, 506, 0, 1678, 1679, 3, 983, - 491, 0, 1679, 1680, 3, 1001, 500, 0, 1680, 1681, 3, 981, 490, 0, 1681, - 1682, 3, 1011, 505, 0, 1682, 90, 1, 0, 0, 0, 1683, 1684, 3, 975, 487, 0, - 1684, 1685, 3, 981, 490, 0, 1685, 1686, 3, 981, 490, 0, 1686, 92, 1, 0, - 0, 0, 1687, 1688, 3, 1011, 505, 0, 1688, 1689, 3, 983, 491, 0, 1689, 1690, - 3, 1013, 506, 0, 1690, 94, 1, 0, 0, 0, 1691, 1692, 3, 1005, 502, 0, 1692, - 1693, 3, 1003, 501, 0, 1693, 1694, 3, 1011, 505, 0, 1694, 1695, 3, 991, - 495, 0, 1695, 1696, 3, 1013, 506, 0, 1696, 1697, 3, 991, 495, 0, 1697, - 1698, 3, 1003, 501, 0, 1698, 1699, 3, 1001, 500, 0, 1699, 96, 1, 0, 0, - 0, 1700, 1701, 3, 981, 490, 0, 1701, 1702, 3, 1003, 501, 0, 1702, 1703, - 3, 979, 489, 0, 1703, 1704, 3, 1015, 507, 0, 1704, 1705, 3, 999, 499, 0, - 1705, 1706, 3, 983, 491, 0, 1706, 1707, 3, 1001, 500, 0, 1707, 1708, 3, - 1013, 506, 0, 1708, 1709, 3, 975, 487, 0, 1709, 1710, 3, 1013, 506, 0, - 1710, 1711, 3, 991, 495, 0, 1711, 1712, 3, 1003, 501, 0, 1712, 1713, 3, - 1001, 500, 0, 1713, 98, 1, 0, 0, 0, 1714, 1715, 3, 1011, 505, 0, 1715, - 1716, 3, 1013, 506, 0, 1716, 1717, 3, 1003, 501, 0, 1717, 1718, 3, 1009, - 504, 0, 1718, 1719, 3, 975, 487, 0, 1719, 1720, 3, 987, 493, 0, 1720, 1721, - 3, 983, 491, 0, 1721, 100, 1, 0, 0, 0, 1722, 1723, 3, 1013, 506, 0, 1723, - 1724, 3, 975, 487, 0, 1724, 1725, 3, 977, 488, 0, 1725, 1726, 3, 997, 498, - 0, 1726, 1727, 3, 983, 491, 0, 1727, 102, 1, 0, 0, 0, 1728, 1729, 3, 981, - 490, 0, 1729, 1730, 3, 983, 491, 0, 1730, 1731, 3, 997, 498, 0, 1731, 1732, - 3, 983, 491, 0, 1732, 1733, 3, 1013, 506, 0, 1733, 1735, 3, 983, 491, 0, - 1734, 1736, 5, 95, 0, 0, 1735, 1734, 1, 0, 0, 0, 1735, 1736, 1, 0, 0, 0, - 1736, 1737, 1, 0, 0, 0, 1737, 1738, 3, 977, 488, 0, 1738, 1739, 3, 983, - 491, 0, 1739, 1740, 3, 989, 494, 0, 1740, 1741, 3, 975, 487, 0, 1741, 1742, - 3, 1017, 508, 0, 1742, 1743, 3, 991, 495, 0, 1743, 1744, 3, 1003, 501, - 0, 1744, 1745, 3, 1009, 504, 0, 1745, 104, 1, 0, 0, 0, 1746, 1747, 3, 979, - 489, 0, 1747, 1748, 3, 975, 487, 0, 1748, 1749, 3, 1011, 505, 0, 1749, - 1750, 3, 979, 489, 0, 1750, 1751, 3, 975, 487, 0, 1751, 1752, 3, 981, 490, - 0, 1752, 1753, 3, 983, 491, 0, 1753, 106, 1, 0, 0, 0, 1754, 1755, 3, 1005, - 502, 0, 1755, 1756, 3, 1009, 504, 0, 1756, 1757, 3, 983, 491, 0, 1757, - 1758, 3, 1017, 508, 0, 1758, 1759, 3, 983, 491, 0, 1759, 1760, 3, 1001, - 500, 0, 1760, 1761, 3, 1013, 506, 0, 1761, 108, 1, 0, 0, 0, 1762, 1763, - 3, 979, 489, 0, 1763, 1764, 3, 1003, 501, 0, 1764, 1765, 3, 1001, 500, - 0, 1765, 1766, 3, 1001, 500, 0, 1766, 1767, 3, 983, 491, 0, 1767, 1768, - 3, 979, 489, 0, 1768, 1769, 3, 1013, 506, 0, 1769, 110, 1, 0, 0, 0, 1770, - 1771, 3, 981, 490, 0, 1771, 1772, 3, 991, 495, 0, 1772, 1773, 3, 1011, - 505, 0, 1773, 1774, 3, 979, 489, 0, 1774, 1775, 3, 1003, 501, 0, 1775, - 1776, 3, 1001, 500, 0, 1776, 1777, 3, 1001, 500, 0, 1777, 1778, 3, 983, - 491, 0, 1778, 1779, 3, 979, 489, 0, 1779, 1780, 3, 1013, 506, 0, 1780, - 112, 1, 0, 0, 0, 1781, 1782, 3, 997, 498, 0, 1782, 1783, 3, 1003, 501, - 0, 1783, 1784, 3, 979, 489, 0, 1784, 1785, 3, 975, 487, 0, 1785, 1786, - 3, 997, 498, 0, 1786, 114, 1, 0, 0, 0, 1787, 1788, 3, 1005, 502, 0, 1788, - 1789, 3, 1009, 504, 0, 1789, 1790, 3, 1003, 501, 0, 1790, 1791, 3, 993, - 496, 0, 1791, 1792, 3, 983, 491, 0, 1792, 1793, 3, 979, 489, 0, 1793, 1794, - 3, 1013, 506, 0, 1794, 116, 1, 0, 0, 0, 1795, 1796, 3, 1009, 504, 0, 1796, - 1797, 3, 1015, 507, 0, 1797, 1798, 3, 1001, 500, 0, 1798, 1799, 3, 1013, - 506, 0, 1799, 1800, 3, 991, 495, 0, 1800, 1801, 3, 999, 499, 0, 1801, 1802, - 3, 983, 491, 0, 1802, 118, 1, 0, 0, 0, 1803, 1804, 3, 977, 488, 0, 1804, - 1805, 3, 1009, 504, 0, 1805, 1806, 3, 975, 487, 0, 1806, 1807, 3, 1001, - 500, 0, 1807, 1808, 3, 979, 489, 0, 1808, 1809, 3, 989, 494, 0, 1809, 120, - 1, 0, 0, 0, 1810, 1811, 3, 1013, 506, 0, 1811, 1812, 3, 1003, 501, 0, 1812, - 1813, 3, 995, 497, 0, 1813, 1814, 3, 983, 491, 0, 1814, 1815, 3, 1001, - 500, 0, 1815, 122, 1, 0, 0, 0, 1816, 1817, 3, 989, 494, 0, 1817, 1818, - 3, 1003, 501, 0, 1818, 1819, 3, 1011, 505, 0, 1819, 1820, 3, 1013, 506, - 0, 1820, 124, 1, 0, 0, 0, 1821, 1822, 3, 1005, 502, 0, 1822, 1823, 3, 1003, - 501, 0, 1823, 1824, 3, 1009, 504, 0, 1824, 1825, 3, 1013, 506, 0, 1825, - 126, 1, 0, 0, 0, 1826, 1827, 3, 1011, 505, 0, 1827, 1828, 3, 989, 494, - 0, 1828, 1829, 3, 1003, 501, 0, 1829, 1830, 3, 1019, 509, 0, 1830, 128, - 1, 0, 0, 0, 1831, 1832, 3, 981, 490, 0, 1832, 1833, 3, 983, 491, 0, 1833, - 1834, 3, 1011, 505, 0, 1834, 1835, 3, 979, 489, 0, 1835, 1836, 3, 1009, - 504, 0, 1836, 1837, 3, 991, 495, 0, 1837, 1838, 3, 977, 488, 0, 1838, 1839, - 3, 983, 491, 0, 1839, 130, 1, 0, 0, 0, 1840, 1841, 3, 1015, 507, 0, 1841, - 1842, 3, 1011, 505, 0, 1842, 1843, 3, 983, 491, 0, 1843, 132, 1, 0, 0, - 0, 1844, 1845, 3, 991, 495, 0, 1845, 1846, 3, 1001, 500, 0, 1846, 1847, - 3, 1013, 506, 0, 1847, 1848, 3, 1009, 504, 0, 1848, 1849, 3, 1003, 501, - 0, 1849, 1850, 3, 1011, 505, 0, 1850, 1851, 3, 1005, 502, 0, 1851, 1852, - 3, 983, 491, 0, 1852, 1853, 3, 979, 489, 0, 1853, 1854, 3, 1013, 506, 0, - 1854, 134, 1, 0, 0, 0, 1855, 1856, 3, 981, 490, 0, 1856, 1857, 3, 983, - 491, 0, 1857, 1858, 3, 977, 488, 0, 1858, 1859, 3, 1015, 507, 0, 1859, - 1860, 3, 987, 493, 0, 1860, 136, 1, 0, 0, 0, 1861, 1862, 3, 1011, 505, - 0, 1862, 1863, 3, 983, 491, 0, 1863, 1864, 3, 997, 498, 0, 1864, 1865, - 3, 983, 491, 0, 1865, 1866, 3, 979, 489, 0, 1866, 1867, 3, 1013, 506, 0, - 1867, 138, 1, 0, 0, 0, 1868, 1869, 3, 985, 492, 0, 1869, 1870, 3, 1009, - 504, 0, 1870, 1871, 3, 1003, 501, 0, 1871, 1872, 3, 999, 499, 0, 1872, - 140, 1, 0, 0, 0, 1873, 1874, 3, 1019, 509, 0, 1874, 1875, 3, 989, 494, - 0, 1875, 1876, 3, 983, 491, 0, 1876, 1877, 3, 1009, 504, 0, 1877, 1878, - 3, 983, 491, 0, 1878, 142, 1, 0, 0, 0, 1879, 1880, 3, 989, 494, 0, 1880, - 1881, 3, 975, 487, 0, 1881, 1882, 3, 1017, 508, 0, 1882, 1883, 3, 991, - 495, 0, 1883, 1884, 3, 1001, 500, 0, 1884, 1885, 3, 987, 493, 0, 1885, - 144, 1, 0, 0, 0, 1886, 1887, 3, 1003, 501, 0, 1887, 1888, 3, 985, 492, - 0, 1888, 1889, 3, 985, 492, 0, 1889, 1890, 3, 1011, 505, 0, 1890, 1891, - 3, 983, 491, 0, 1891, 1892, 3, 1013, 506, 0, 1892, 146, 1, 0, 0, 0, 1893, - 1894, 3, 997, 498, 0, 1894, 1895, 3, 991, 495, 0, 1895, 1896, 3, 999, 499, - 0, 1896, 1897, 3, 991, 495, 0, 1897, 1898, 3, 1013, 506, 0, 1898, 148, - 1, 0, 0, 0, 1899, 1900, 3, 975, 487, 0, 1900, 1901, 3, 1011, 505, 0, 1901, - 150, 1, 0, 0, 0, 1902, 1903, 3, 1009, 504, 0, 1903, 1904, 3, 983, 491, - 0, 1904, 1905, 3, 1013, 506, 0, 1905, 1906, 3, 1015, 507, 0, 1906, 1907, - 3, 1009, 504, 0, 1907, 1908, 3, 1001, 500, 0, 1908, 1909, 3, 1011, 505, - 0, 1909, 152, 1, 0, 0, 0, 1910, 1911, 3, 1009, 504, 0, 1911, 1912, 3, 983, - 491, 0, 1912, 1913, 3, 1013, 506, 0, 1913, 1914, 3, 1015, 507, 0, 1914, - 1915, 3, 1009, 504, 0, 1915, 1916, 3, 1001, 500, 0, 1916, 1917, 3, 991, - 495, 0, 1917, 1918, 3, 1001, 500, 0, 1918, 1919, 3, 987, 493, 0, 1919, - 154, 1, 0, 0, 0, 1920, 1921, 3, 979, 489, 0, 1921, 1922, 3, 975, 487, 0, - 1922, 1923, 3, 1011, 505, 0, 1923, 1924, 3, 983, 491, 0, 1924, 156, 1, - 0, 0, 0, 1925, 1926, 3, 1019, 509, 0, 1926, 1927, 3, 989, 494, 0, 1927, - 1928, 3, 983, 491, 0, 1928, 1929, 3, 1001, 500, 0, 1929, 158, 1, 0, 0, - 0, 1930, 1931, 3, 1013, 506, 0, 1931, 1932, 3, 989, 494, 0, 1932, 1933, - 3, 983, 491, 0, 1933, 1934, 3, 1001, 500, 0, 1934, 160, 1, 0, 0, 0, 1935, - 1936, 3, 983, 491, 0, 1936, 1937, 3, 997, 498, 0, 1937, 1938, 3, 1011, - 505, 0, 1938, 1939, 3, 983, 491, 0, 1939, 162, 1, 0, 0, 0, 1940, 1941, - 3, 983, 491, 0, 1941, 1942, 3, 1001, 500, 0, 1942, 1943, 3, 981, 490, 0, - 1943, 164, 1, 0, 0, 0, 1944, 1945, 3, 981, 490, 0, 1945, 1946, 3, 991, - 495, 0, 1946, 1947, 3, 1011, 505, 0, 1947, 1948, 3, 1013, 506, 0, 1948, - 1949, 3, 991, 495, 0, 1949, 1950, 3, 1001, 500, 0, 1950, 1951, 3, 979, - 489, 0, 1951, 1952, 3, 1013, 506, 0, 1952, 166, 1, 0, 0, 0, 1953, 1954, - 3, 975, 487, 0, 1954, 1955, 3, 997, 498, 0, 1955, 1956, 3, 997, 498, 0, - 1956, 168, 1, 0, 0, 0, 1957, 1958, 3, 993, 496, 0, 1958, 1959, 3, 1003, - 501, 0, 1959, 1960, 3, 991, 495, 0, 1960, 1961, 3, 1001, 500, 0, 1961, - 170, 1, 0, 0, 0, 1962, 1963, 3, 997, 498, 0, 1963, 1964, 3, 983, 491, 0, - 1964, 1965, 3, 985, 492, 0, 1965, 1966, 3, 1013, 506, 0, 1966, 172, 1, - 0, 0, 0, 1967, 1968, 3, 1009, 504, 0, 1968, 1969, 3, 991, 495, 0, 1969, - 1970, 3, 987, 493, 0, 1970, 1971, 3, 989, 494, 0, 1971, 1972, 3, 1013, - 506, 0, 1972, 174, 1, 0, 0, 0, 1973, 1974, 3, 991, 495, 0, 1974, 1975, - 3, 1001, 500, 0, 1975, 1976, 3, 1001, 500, 0, 1976, 1977, 3, 983, 491, - 0, 1977, 1978, 3, 1009, 504, 0, 1978, 176, 1, 0, 0, 0, 1979, 1980, 3, 1003, - 501, 0, 1980, 1981, 3, 1015, 507, 0, 1981, 1982, 3, 1013, 506, 0, 1982, - 1983, 3, 983, 491, 0, 1983, 1984, 3, 1009, 504, 0, 1984, 178, 1, 0, 0, - 0, 1985, 1986, 3, 985, 492, 0, 1986, 1987, 3, 1015, 507, 0, 1987, 1988, - 3, 997, 498, 0, 1988, 1989, 3, 997, 498, 0, 1989, 180, 1, 0, 0, 0, 1990, - 1991, 3, 979, 489, 0, 1991, 1992, 3, 1009, 504, 0, 1992, 1993, 3, 1003, - 501, 0, 1993, 1994, 3, 1011, 505, 0, 1994, 1995, 3, 1011, 505, 0, 1995, - 182, 1, 0, 0, 0, 1996, 1997, 3, 1003, 501, 0, 1997, 1998, 3, 1001, 500, - 0, 1998, 184, 1, 0, 0, 0, 1999, 2000, 3, 975, 487, 0, 2000, 2001, 3, 1011, - 505, 0, 2001, 2002, 3, 979, 489, 0, 2002, 186, 1, 0, 0, 0, 2003, 2004, - 3, 981, 490, 0, 2004, 2005, 3, 983, 491, 0, 2005, 2006, 3, 1011, 505, 0, - 2006, 2007, 3, 979, 489, 0, 2007, 188, 1, 0, 0, 0, 2008, 2009, 3, 977, - 488, 0, 2009, 2010, 3, 983, 491, 0, 2010, 2011, 3, 987, 493, 0, 2011, 2012, - 3, 991, 495, 0, 2012, 2013, 3, 1001, 500, 0, 2013, 190, 1, 0, 0, 0, 2014, - 2015, 3, 981, 490, 0, 2015, 2016, 3, 983, 491, 0, 2016, 2017, 3, 979, 489, - 0, 2017, 2018, 3, 997, 498, 0, 2018, 2019, 3, 975, 487, 0, 2019, 2020, - 3, 1009, 504, 0, 2020, 2021, 3, 983, 491, 0, 2021, 192, 1, 0, 0, 0, 2022, - 2023, 3, 979, 489, 0, 2023, 2024, 3, 989, 494, 0, 2024, 2025, 3, 975, 487, - 0, 2025, 2026, 3, 1001, 500, 0, 2026, 2027, 3, 987, 493, 0, 2027, 2028, - 3, 983, 491, 0, 2028, 194, 1, 0, 0, 0, 2029, 2030, 3, 1009, 504, 0, 2030, - 2031, 3, 983, 491, 0, 2031, 2032, 3, 1013, 506, 0, 2032, 2033, 3, 1009, - 504, 0, 2033, 2034, 3, 991, 495, 0, 2034, 2035, 3, 983, 491, 0, 2035, 2036, - 3, 1017, 508, 0, 2036, 2037, 3, 983, 491, 0, 2037, 196, 1, 0, 0, 0, 2038, - 2039, 3, 981, 490, 0, 2039, 2040, 3, 983, 491, 0, 2040, 2041, 3, 997, 498, - 0, 2041, 2042, 3, 983, 491, 0, 2042, 2043, 3, 1013, 506, 0, 2043, 2044, - 3, 983, 491, 0, 2044, 198, 1, 0, 0, 0, 2045, 2046, 3, 979, 489, 0, 2046, - 2047, 3, 1003, 501, 0, 2047, 2048, 3, 999, 499, 0, 2048, 2049, 3, 999, - 499, 0, 2049, 2050, 3, 991, 495, 0, 2050, 2051, 3, 1013, 506, 0, 2051, - 200, 1, 0, 0, 0, 2052, 2053, 3, 1009, 504, 0, 2053, 2054, 3, 1003, 501, - 0, 2054, 2055, 3, 997, 498, 0, 2055, 2056, 3, 997, 498, 0, 2056, 2057, - 3, 977, 488, 0, 2057, 2058, 3, 975, 487, 0, 2058, 2059, 3, 979, 489, 0, - 2059, 2060, 3, 995, 497, 0, 2060, 202, 1, 0, 0, 0, 2061, 2062, 3, 997, - 498, 0, 2062, 2063, 3, 1003, 501, 0, 2063, 2064, 3, 1003, 501, 0, 2064, - 2065, 3, 1005, 502, 0, 2065, 204, 1, 0, 0, 0, 2066, 2067, 3, 1019, 509, - 0, 2067, 2068, 3, 989, 494, 0, 2068, 2069, 3, 991, 495, 0, 2069, 2070, - 3, 997, 498, 0, 2070, 2071, 3, 983, 491, 0, 2071, 206, 1, 0, 0, 0, 2072, - 2073, 3, 991, 495, 0, 2073, 2074, 3, 985, 492, 0, 2074, 208, 1, 0, 0, 0, - 2075, 2076, 3, 983, 491, 0, 2076, 2077, 3, 997, 498, 0, 2077, 2078, 3, - 1011, 505, 0, 2078, 2079, 3, 991, 495, 0, 2079, 2080, 3, 985, 492, 0, 2080, - 210, 1, 0, 0, 0, 2081, 2082, 3, 983, 491, 0, 2082, 2083, 3, 997, 498, 0, - 2083, 2084, 3, 1011, 505, 0, 2084, 2085, 3, 983, 491, 0, 2085, 2086, 3, - 991, 495, 0, 2086, 2087, 3, 985, 492, 0, 2087, 212, 1, 0, 0, 0, 2088, 2089, - 3, 979, 489, 0, 2089, 2090, 3, 1003, 501, 0, 2090, 2091, 3, 1001, 500, - 0, 2091, 2092, 3, 1013, 506, 0, 2092, 2093, 3, 991, 495, 0, 2093, 2094, - 3, 1001, 500, 0, 2094, 2095, 3, 1015, 507, 0, 2095, 2096, 3, 983, 491, - 0, 2096, 214, 1, 0, 0, 0, 2097, 2098, 3, 977, 488, 0, 2098, 2099, 3, 1009, - 504, 0, 2099, 2100, 3, 983, 491, 0, 2100, 2101, 3, 975, 487, 0, 2101, 2102, - 3, 995, 497, 0, 2102, 216, 1, 0, 0, 0, 2103, 2104, 3, 1009, 504, 0, 2104, - 2105, 3, 983, 491, 0, 2105, 2106, 3, 1013, 506, 0, 2106, 2107, 3, 1015, - 507, 0, 2107, 2108, 3, 1009, 504, 0, 2108, 2109, 3, 1001, 500, 0, 2109, - 218, 1, 0, 0, 0, 2110, 2111, 3, 1013, 506, 0, 2111, 2112, 3, 989, 494, - 0, 2112, 2113, 3, 1009, 504, 0, 2113, 2114, 3, 1003, 501, 0, 2114, 2115, - 3, 1019, 509, 0, 2115, 220, 1, 0, 0, 0, 2116, 2117, 3, 997, 498, 0, 2117, - 2118, 3, 1003, 501, 0, 2118, 2119, 3, 987, 493, 0, 2119, 222, 1, 0, 0, - 0, 2120, 2121, 3, 979, 489, 0, 2121, 2122, 3, 975, 487, 0, 2122, 2123, - 3, 997, 498, 0, 2123, 2124, 3, 997, 498, 0, 2124, 224, 1, 0, 0, 0, 2125, - 2126, 3, 993, 496, 0, 2126, 2127, 3, 975, 487, 0, 2127, 2128, 3, 1017, - 508, 0, 2128, 2129, 3, 975, 487, 0, 2129, 226, 1, 0, 0, 0, 2130, 2131, - 3, 975, 487, 0, 2131, 2132, 3, 979, 489, 0, 2132, 2133, 3, 1013, 506, 0, - 2133, 2134, 3, 991, 495, 0, 2134, 2135, 3, 1003, 501, 0, 2135, 2136, 3, - 1001, 500, 0, 2136, 228, 1, 0, 0, 0, 2137, 2138, 3, 975, 487, 0, 2138, - 2139, 3, 979, 489, 0, 2139, 2140, 3, 1013, 506, 0, 2140, 2141, 3, 991, - 495, 0, 2141, 2142, 3, 1003, 501, 0, 2142, 2143, 3, 1001, 500, 0, 2143, - 2144, 3, 1011, 505, 0, 2144, 230, 1, 0, 0, 0, 2145, 2146, 3, 979, 489, - 0, 2146, 2147, 3, 997, 498, 0, 2147, 2148, 3, 1003, 501, 0, 2148, 2149, - 3, 1011, 505, 0, 2149, 2150, 3, 983, 491, 0, 2150, 232, 1, 0, 0, 0, 2151, - 2152, 3, 1001, 500, 0, 2152, 2153, 3, 1003, 501, 0, 2153, 2154, 3, 981, - 490, 0, 2154, 2155, 3, 983, 491, 0, 2155, 234, 1, 0, 0, 0, 2156, 2157, - 3, 983, 491, 0, 2157, 2158, 3, 1017, 508, 0, 2158, 2159, 3, 983, 491, 0, - 2159, 2160, 3, 1001, 500, 0, 2160, 2161, 3, 1013, 506, 0, 2161, 2162, 3, - 1011, 505, 0, 2162, 236, 1, 0, 0, 0, 2163, 2164, 3, 989, 494, 0, 2164, - 2165, 3, 983, 491, 0, 2165, 2166, 3, 975, 487, 0, 2166, 2167, 3, 981, 490, - 0, 2167, 238, 1, 0, 0, 0, 2168, 2169, 3, 1013, 506, 0, 2169, 2170, 3, 975, - 487, 0, 2170, 2171, 3, 991, 495, 0, 2171, 2172, 3, 997, 498, 0, 2172, 240, - 1, 0, 0, 0, 2173, 2174, 3, 985, 492, 0, 2174, 2175, 3, 991, 495, 0, 2175, - 2176, 3, 1001, 500, 0, 2176, 2177, 3, 981, 490, 0, 2177, 242, 1, 0, 0, - 0, 2178, 2179, 3, 1011, 505, 0, 2179, 2180, 3, 1003, 501, 0, 2180, 2181, - 3, 1009, 504, 0, 2181, 2182, 3, 1013, 506, 0, 2182, 244, 1, 0, 0, 0, 2183, - 2184, 3, 1015, 507, 0, 2184, 2185, 3, 1001, 500, 0, 2185, 2186, 3, 991, - 495, 0, 2186, 2187, 3, 1003, 501, 0, 2187, 2188, 3, 1001, 500, 0, 2188, - 246, 1, 0, 0, 0, 2189, 2190, 3, 991, 495, 0, 2190, 2191, 3, 1001, 500, - 0, 2191, 2192, 3, 1013, 506, 0, 2192, 2193, 3, 983, 491, 0, 2193, 2194, - 3, 1009, 504, 0, 2194, 2195, 3, 1011, 505, 0, 2195, 2196, 3, 983, 491, - 0, 2196, 2197, 3, 979, 489, 0, 2197, 2198, 3, 1013, 506, 0, 2198, 248, - 1, 0, 0, 0, 2199, 2200, 3, 1011, 505, 0, 2200, 2201, 3, 1015, 507, 0, 2201, - 2202, 3, 977, 488, 0, 2202, 2203, 3, 1013, 506, 0, 2203, 2204, 3, 1009, - 504, 0, 2204, 2205, 3, 975, 487, 0, 2205, 2206, 3, 979, 489, 0, 2206, 2207, - 3, 1013, 506, 0, 2207, 250, 1, 0, 0, 0, 2208, 2209, 3, 979, 489, 0, 2209, - 2210, 3, 1003, 501, 0, 2210, 2211, 3, 1001, 500, 0, 2211, 2212, 3, 1013, - 506, 0, 2212, 2213, 3, 975, 487, 0, 2213, 2214, 3, 991, 495, 0, 2214, 2215, - 3, 1001, 500, 0, 2215, 2216, 3, 1011, 505, 0, 2216, 252, 1, 0, 0, 0, 2217, - 2218, 3, 975, 487, 0, 2218, 2219, 3, 1017, 508, 0, 2219, 2220, 3, 983, - 491, 0, 2220, 2221, 3, 1009, 504, 0, 2221, 2222, 3, 975, 487, 0, 2222, - 2223, 3, 987, 493, 0, 2223, 2224, 3, 983, 491, 0, 2224, 254, 1, 0, 0, 0, - 2225, 2226, 3, 999, 499, 0, 2226, 2227, 3, 991, 495, 0, 2227, 2228, 3, - 1001, 500, 0, 2228, 2229, 3, 991, 495, 0, 2229, 2230, 3, 999, 499, 0, 2230, - 2231, 3, 1015, 507, 0, 2231, 2232, 3, 999, 499, 0, 2232, 256, 1, 0, 0, - 0, 2233, 2234, 3, 999, 499, 0, 2234, 2235, 3, 975, 487, 0, 2235, 2236, - 3, 1021, 510, 0, 2236, 2237, 3, 991, 495, 0, 2237, 2238, 3, 999, 499, 0, - 2238, 2239, 3, 1015, 507, 0, 2239, 2240, 3, 999, 499, 0, 2240, 258, 1, - 0, 0, 0, 2241, 2242, 3, 997, 498, 0, 2242, 2243, 3, 991, 495, 0, 2243, - 2244, 3, 1011, 505, 0, 2244, 2245, 3, 1013, 506, 0, 2245, 260, 1, 0, 0, - 0, 2246, 2247, 3, 1009, 504, 0, 2247, 2248, 3, 983, 491, 0, 2248, 2249, - 3, 999, 499, 0, 2249, 2250, 3, 1003, 501, 0, 2250, 2251, 3, 1017, 508, - 0, 2251, 2252, 3, 983, 491, 0, 2252, 262, 1, 0, 0, 0, 2253, 2254, 3, 983, - 491, 0, 2254, 2255, 3, 1007, 503, 0, 2255, 2256, 3, 1015, 507, 0, 2256, - 2257, 3, 975, 487, 0, 2257, 2258, 3, 997, 498, 0, 2258, 2259, 3, 1011, - 505, 0, 2259, 264, 1, 0, 0, 0, 2260, 2261, 3, 991, 495, 0, 2261, 2262, - 3, 1001, 500, 0, 2262, 2263, 3, 985, 492, 0, 2263, 2264, 3, 1003, 501, - 0, 2264, 266, 1, 0, 0, 0, 2265, 2266, 3, 1019, 509, 0, 2266, 2267, 3, 975, - 487, 0, 2267, 2268, 3, 1009, 504, 0, 2268, 2269, 3, 1001, 500, 0, 2269, - 2270, 3, 991, 495, 0, 2270, 2271, 3, 1001, 500, 0, 2271, 2272, 3, 987, - 493, 0, 2272, 268, 1, 0, 0, 0, 2273, 2274, 3, 1013, 506, 0, 2274, 2275, - 3, 1009, 504, 0, 2275, 2276, 3, 975, 487, 0, 2276, 2277, 3, 979, 489, 0, - 2277, 2278, 3, 983, 491, 0, 2278, 270, 1, 0, 0, 0, 2279, 2280, 3, 979, - 489, 0, 2280, 2281, 3, 1009, 504, 0, 2281, 2282, 3, 991, 495, 0, 2282, - 2283, 3, 1013, 506, 0, 2283, 2284, 3, 991, 495, 0, 2284, 2285, 3, 979, - 489, 0, 2285, 2286, 3, 975, 487, 0, 2286, 2287, 3, 997, 498, 0, 2287, 272, - 1, 0, 0, 0, 2288, 2289, 3, 1019, 509, 0, 2289, 2290, 3, 991, 495, 0, 2290, - 2291, 3, 1013, 506, 0, 2291, 2292, 3, 989, 494, 0, 2292, 274, 1, 0, 0, - 0, 2293, 2294, 3, 983, 491, 0, 2294, 2295, 3, 999, 499, 0, 2295, 2296, - 3, 1005, 502, 0, 2296, 2297, 3, 1013, 506, 0, 2297, 2298, 3, 1023, 511, - 0, 2298, 276, 1, 0, 0, 0, 2299, 2300, 3, 1003, 501, 0, 2300, 2301, 3, 977, - 488, 0, 2301, 2302, 3, 993, 496, 0, 2302, 2303, 3, 983, 491, 0, 2303, 2304, - 3, 979, 489, 0, 2304, 2305, 3, 1013, 506, 0, 2305, 278, 1, 0, 0, 0, 2306, - 2307, 3, 1003, 501, 0, 2307, 2308, 3, 977, 488, 0, 2308, 2309, 3, 993, - 496, 0, 2309, 2310, 3, 983, 491, 0, 2310, 2311, 3, 979, 489, 0, 2311, 2312, - 3, 1013, 506, 0, 2312, 2313, 3, 1011, 505, 0, 2313, 280, 1, 0, 0, 0, 2314, - 2315, 3, 1005, 502, 0, 2315, 2316, 3, 975, 487, 0, 2316, 2317, 3, 987, - 493, 0, 2317, 2318, 3, 983, 491, 0, 2318, 2319, 3, 1011, 505, 0, 2319, - 282, 1, 0, 0, 0, 2320, 2321, 3, 997, 498, 0, 2321, 2322, 3, 975, 487, 0, - 2322, 2323, 3, 1023, 511, 0, 2323, 2324, 3, 1003, 501, 0, 2324, 2325, 3, - 1015, 507, 0, 2325, 2326, 3, 1013, 506, 0, 2326, 2327, 3, 1011, 505, 0, - 2327, 284, 1, 0, 0, 0, 2328, 2329, 3, 1011, 505, 0, 2329, 2330, 3, 1001, - 500, 0, 2330, 2331, 3, 991, 495, 0, 2331, 2332, 3, 1005, 502, 0, 2332, - 2333, 3, 1005, 502, 0, 2333, 2334, 3, 983, 491, 0, 2334, 2335, 3, 1013, - 506, 0, 2335, 2336, 3, 1011, 505, 0, 2336, 286, 1, 0, 0, 0, 2337, 2338, - 3, 1001, 500, 0, 2338, 2339, 3, 1003, 501, 0, 2339, 2340, 3, 1013, 506, - 0, 2340, 2341, 3, 983, 491, 0, 2341, 2342, 3, 977, 488, 0, 2342, 2343, - 3, 1003, 501, 0, 2343, 2344, 3, 1003, 501, 0, 2344, 2345, 3, 995, 497, - 0, 2345, 2346, 3, 1011, 505, 0, 2346, 288, 1, 0, 0, 0, 2347, 2348, 3, 1005, - 502, 0, 2348, 2349, 3, 997, 498, 0, 2349, 2350, 3, 975, 487, 0, 2350, 2351, - 3, 979, 489, 0, 2351, 2352, 3, 983, 491, 0, 2352, 2353, 3, 989, 494, 0, - 2353, 2354, 3, 1003, 501, 0, 2354, 2355, 3, 997, 498, 0, 2355, 2356, 3, - 981, 490, 0, 2356, 2357, 3, 983, 491, 0, 2357, 2358, 3, 1009, 504, 0, 2358, - 290, 1, 0, 0, 0, 2359, 2360, 3, 1011, 505, 0, 2360, 2361, 3, 1001, 500, - 0, 2361, 2362, 3, 991, 495, 0, 2362, 2363, 3, 1005, 502, 0, 2363, 2364, - 3, 1005, 502, 0, 2364, 2365, 3, 983, 491, 0, 2365, 2366, 3, 1013, 506, - 0, 2366, 2367, 3, 979, 489, 0, 2367, 2368, 3, 975, 487, 0, 2368, 2369, - 3, 997, 498, 0, 2369, 2370, 3, 997, 498, 0, 2370, 292, 1, 0, 0, 0, 2371, - 2372, 3, 997, 498, 0, 2372, 2373, 3, 975, 487, 0, 2373, 2374, 3, 1023, - 511, 0, 2374, 2375, 3, 1003, 501, 0, 2375, 2376, 3, 1015, 507, 0, 2376, - 2377, 3, 1013, 506, 0, 2377, 2378, 3, 987, 493, 0, 2378, 2379, 3, 1009, - 504, 0, 2379, 2380, 3, 991, 495, 0, 2380, 2381, 3, 981, 490, 0, 2381, 294, - 1, 0, 0, 0, 2382, 2383, 3, 981, 490, 0, 2383, 2384, 3, 975, 487, 0, 2384, - 2385, 3, 1013, 506, 0, 2385, 2386, 3, 975, 487, 0, 2386, 2387, 3, 987, - 493, 0, 2387, 2388, 3, 1009, 504, 0, 2388, 2389, 3, 991, 495, 0, 2389, - 2390, 3, 981, 490, 0, 2390, 296, 1, 0, 0, 0, 2391, 2392, 3, 981, 490, 0, - 2392, 2393, 3, 975, 487, 0, 2393, 2394, 3, 1013, 506, 0, 2394, 2395, 3, - 975, 487, 0, 2395, 2396, 3, 1017, 508, 0, 2396, 2397, 3, 991, 495, 0, 2397, - 2398, 3, 983, 491, 0, 2398, 2399, 3, 1019, 509, 0, 2399, 298, 1, 0, 0, - 0, 2400, 2401, 3, 997, 498, 0, 2401, 2402, 3, 991, 495, 0, 2402, 2403, - 3, 1011, 505, 0, 2403, 2404, 3, 1013, 506, 0, 2404, 2405, 3, 1017, 508, - 0, 2405, 2406, 3, 991, 495, 0, 2406, 2407, 3, 983, 491, 0, 2407, 2408, - 3, 1019, 509, 0, 2408, 300, 1, 0, 0, 0, 2409, 2410, 3, 987, 493, 0, 2410, - 2411, 3, 975, 487, 0, 2411, 2412, 3, 997, 498, 0, 2412, 2413, 3, 997, 498, - 0, 2413, 2414, 3, 983, 491, 0, 2414, 2415, 3, 1009, 504, 0, 2415, 2416, - 3, 1023, 511, 0, 2416, 302, 1, 0, 0, 0, 2417, 2418, 3, 979, 489, 0, 2418, - 2419, 3, 1003, 501, 0, 2419, 2420, 3, 1001, 500, 0, 2420, 2421, 3, 1013, - 506, 0, 2421, 2422, 3, 975, 487, 0, 2422, 2423, 3, 991, 495, 0, 2423, 2424, - 3, 1001, 500, 0, 2424, 2425, 3, 983, 491, 0, 2425, 2426, 3, 1009, 504, - 0, 2426, 304, 1, 0, 0, 0, 2427, 2428, 3, 1009, 504, 0, 2428, 2429, 3, 1003, - 501, 0, 2429, 2430, 3, 1019, 509, 0, 2430, 306, 1, 0, 0, 0, 2431, 2432, - 3, 991, 495, 0, 2432, 2433, 3, 1013, 506, 0, 2433, 2434, 3, 983, 491, 0, - 2434, 2435, 3, 999, 499, 0, 2435, 308, 1, 0, 0, 0, 2436, 2437, 3, 979, - 489, 0, 2437, 2438, 3, 1003, 501, 0, 2438, 2439, 3, 1001, 500, 0, 2439, - 2440, 3, 1013, 506, 0, 2440, 2441, 3, 1009, 504, 0, 2441, 2442, 3, 1003, - 501, 0, 2442, 2443, 3, 997, 498, 0, 2443, 2444, 3, 977, 488, 0, 2444, 2445, - 3, 975, 487, 0, 2445, 2446, 3, 1009, 504, 0, 2446, 310, 1, 0, 0, 0, 2447, - 2448, 3, 1011, 505, 0, 2448, 2449, 3, 983, 491, 0, 2449, 2450, 3, 975, - 487, 0, 2450, 2451, 3, 1009, 504, 0, 2451, 2452, 3, 979, 489, 0, 2452, - 2453, 3, 989, 494, 0, 2453, 312, 1, 0, 0, 0, 2454, 2455, 3, 1011, 505, - 0, 2455, 2456, 3, 983, 491, 0, 2456, 2457, 3, 975, 487, 0, 2457, 2458, - 3, 1009, 504, 0, 2458, 2459, 3, 979, 489, 0, 2459, 2460, 3, 989, 494, 0, - 2460, 2461, 3, 977, 488, 0, 2461, 2462, 3, 975, 487, 0, 2462, 2463, 3, - 1009, 504, 0, 2463, 314, 1, 0, 0, 0, 2464, 2465, 3, 1001, 500, 0, 2465, - 2466, 3, 975, 487, 0, 2466, 2467, 3, 1017, 508, 0, 2467, 2468, 3, 991, - 495, 0, 2468, 2469, 3, 987, 493, 0, 2469, 2470, 3, 975, 487, 0, 2470, 2471, - 3, 1013, 506, 0, 2471, 2472, 3, 991, 495, 0, 2472, 2473, 3, 1003, 501, - 0, 2473, 2474, 3, 1001, 500, 0, 2474, 2475, 3, 997, 498, 0, 2475, 2476, - 3, 991, 495, 0, 2476, 2477, 3, 1011, 505, 0, 2477, 2478, 3, 1013, 506, - 0, 2478, 316, 1, 0, 0, 0, 2479, 2480, 3, 975, 487, 0, 2480, 2481, 3, 979, - 489, 0, 2481, 2482, 3, 1013, 506, 0, 2482, 2483, 3, 991, 495, 0, 2483, - 2484, 3, 1003, 501, 0, 2484, 2485, 3, 1001, 500, 0, 2485, 2486, 3, 977, - 488, 0, 2486, 2487, 3, 1015, 507, 0, 2487, 2488, 3, 1013, 506, 0, 2488, - 2489, 3, 1013, 506, 0, 2489, 2490, 3, 1003, 501, 0, 2490, 2491, 3, 1001, - 500, 0, 2491, 318, 1, 0, 0, 0, 2492, 2493, 3, 997, 498, 0, 2493, 2494, - 3, 991, 495, 0, 2494, 2495, 3, 1001, 500, 0, 2495, 2496, 3, 995, 497, 0, - 2496, 2497, 3, 977, 488, 0, 2497, 2498, 3, 1015, 507, 0, 2498, 2499, 3, - 1013, 506, 0, 2499, 2500, 3, 1013, 506, 0, 2500, 2501, 3, 1003, 501, 0, - 2501, 2502, 3, 1001, 500, 0, 2502, 320, 1, 0, 0, 0, 2503, 2504, 3, 977, - 488, 0, 2504, 2505, 3, 1015, 507, 0, 2505, 2506, 3, 1013, 506, 0, 2506, - 2507, 3, 1013, 506, 0, 2507, 2508, 3, 1003, 501, 0, 2508, 2509, 3, 1001, - 500, 0, 2509, 322, 1, 0, 0, 0, 2510, 2511, 3, 1013, 506, 0, 2511, 2512, - 3, 991, 495, 0, 2512, 2513, 3, 1013, 506, 0, 2513, 2514, 3, 997, 498, 0, - 2514, 2515, 3, 983, 491, 0, 2515, 324, 1, 0, 0, 0, 2516, 2517, 3, 981, - 490, 0, 2517, 2518, 3, 1023, 511, 0, 2518, 2519, 3, 1001, 500, 0, 2519, - 2520, 3, 975, 487, 0, 2520, 2521, 3, 999, 499, 0, 2521, 2522, 3, 991, 495, - 0, 2522, 2523, 3, 979, 489, 0, 2523, 2524, 3, 1013, 506, 0, 2524, 2525, - 3, 983, 491, 0, 2525, 2526, 3, 1021, 510, 0, 2526, 2527, 3, 1013, 506, - 0, 2527, 326, 1, 0, 0, 0, 2528, 2529, 3, 981, 490, 0, 2529, 2530, 3, 1023, - 511, 0, 2530, 2531, 3, 1001, 500, 0, 2531, 2532, 3, 975, 487, 0, 2532, - 2533, 3, 999, 499, 0, 2533, 2534, 3, 991, 495, 0, 2534, 2535, 3, 979, 489, - 0, 2535, 328, 1, 0, 0, 0, 2536, 2537, 3, 1011, 505, 0, 2537, 2538, 3, 1013, - 506, 0, 2538, 2539, 3, 975, 487, 0, 2539, 2540, 3, 1013, 506, 0, 2540, - 2541, 3, 991, 495, 0, 2541, 2542, 3, 979, 489, 0, 2542, 2543, 3, 1013, - 506, 0, 2543, 2544, 3, 983, 491, 0, 2544, 2545, 3, 1021, 510, 0, 2545, - 2546, 3, 1013, 506, 0, 2546, 330, 1, 0, 0, 0, 2547, 2548, 3, 997, 498, - 0, 2548, 2549, 3, 975, 487, 0, 2549, 2550, 3, 977, 488, 0, 2550, 2551, - 3, 983, 491, 0, 2551, 2552, 3, 997, 498, 0, 2552, 332, 1, 0, 0, 0, 2553, - 2554, 3, 1013, 506, 0, 2554, 2555, 3, 983, 491, 0, 2555, 2556, 3, 1021, - 510, 0, 2556, 2557, 3, 1013, 506, 0, 2557, 2558, 3, 977, 488, 0, 2558, - 2559, 3, 1003, 501, 0, 2559, 2560, 3, 1021, 510, 0, 2560, 334, 1, 0, 0, - 0, 2561, 2562, 3, 1013, 506, 0, 2562, 2563, 3, 983, 491, 0, 2563, 2564, - 3, 1021, 510, 0, 2564, 2565, 3, 1013, 506, 0, 2565, 2566, 3, 975, 487, - 0, 2566, 2567, 3, 1009, 504, 0, 2567, 2568, 3, 983, 491, 0, 2568, 2569, - 3, 975, 487, 0, 2569, 336, 1, 0, 0, 0, 2570, 2571, 3, 981, 490, 0, 2571, - 2572, 3, 975, 487, 0, 2572, 2573, 3, 1013, 506, 0, 2573, 2574, 3, 983, - 491, 0, 2574, 2575, 3, 1005, 502, 0, 2575, 2576, 3, 991, 495, 0, 2576, - 2577, 3, 979, 489, 0, 2577, 2578, 3, 995, 497, 0, 2578, 2579, 3, 983, 491, - 0, 2579, 2580, 3, 1009, 504, 0, 2580, 338, 1, 0, 0, 0, 2581, 2582, 3, 1009, - 504, 0, 2582, 2583, 3, 975, 487, 0, 2583, 2584, 3, 981, 490, 0, 2584, 2585, - 3, 991, 495, 0, 2585, 2586, 3, 1003, 501, 0, 2586, 2587, 3, 977, 488, 0, - 2587, 2588, 3, 1015, 507, 0, 2588, 2589, 3, 1013, 506, 0, 2589, 2590, 3, - 1013, 506, 0, 2590, 2591, 3, 1003, 501, 0, 2591, 2592, 3, 1001, 500, 0, - 2592, 2593, 3, 1011, 505, 0, 2593, 340, 1, 0, 0, 0, 2594, 2595, 3, 981, - 490, 0, 2595, 2596, 3, 1009, 504, 0, 2596, 2597, 3, 1003, 501, 0, 2597, - 2598, 3, 1005, 502, 0, 2598, 2599, 3, 981, 490, 0, 2599, 2600, 3, 1003, - 501, 0, 2600, 2601, 3, 1019, 509, 0, 2601, 2602, 3, 1001, 500, 0, 2602, - 342, 1, 0, 0, 0, 2603, 2604, 3, 979, 489, 0, 2604, 2605, 3, 1003, 501, - 0, 2605, 2606, 3, 999, 499, 0, 2606, 2607, 3, 977, 488, 0, 2607, 2608, - 3, 1003, 501, 0, 2608, 2609, 3, 977, 488, 0, 2609, 2610, 3, 1003, 501, - 0, 2610, 2611, 3, 1021, 510, 0, 2611, 344, 1, 0, 0, 0, 2612, 2613, 3, 979, - 489, 0, 2613, 2614, 3, 989, 494, 0, 2614, 2615, 3, 983, 491, 0, 2615, 2616, - 3, 979, 489, 0, 2616, 2617, 3, 995, 497, 0, 2617, 2618, 3, 977, 488, 0, - 2618, 2619, 3, 1003, 501, 0, 2619, 2620, 3, 1021, 510, 0, 2620, 346, 1, - 0, 0, 0, 2621, 2622, 3, 1009, 504, 0, 2622, 2623, 3, 983, 491, 0, 2623, - 2624, 3, 985, 492, 0, 2624, 2625, 3, 983, 491, 0, 2625, 2626, 3, 1009, - 504, 0, 2626, 2627, 3, 983, 491, 0, 2627, 2628, 3, 1001, 500, 0, 2628, - 2629, 3, 979, 489, 0, 2629, 2630, 3, 983, 491, 0, 2630, 2631, 3, 1011, - 505, 0, 2631, 2632, 3, 983, 491, 0, 2632, 2633, 3, 997, 498, 0, 2633, 2634, - 3, 983, 491, 0, 2634, 2635, 3, 979, 489, 0, 2635, 2636, 3, 1013, 506, 0, - 2636, 2637, 3, 1003, 501, 0, 2637, 2638, 3, 1009, 504, 0, 2638, 348, 1, - 0, 0, 0, 2639, 2640, 3, 991, 495, 0, 2640, 2641, 3, 1001, 500, 0, 2641, - 2642, 3, 1005, 502, 0, 2642, 2643, 3, 1015, 507, 0, 2643, 2644, 3, 1013, - 506, 0, 2644, 2645, 3, 1009, 504, 0, 2645, 2646, 3, 983, 491, 0, 2646, - 2647, 3, 985, 492, 0, 2647, 2648, 3, 983, 491, 0, 2648, 2649, 3, 1009, - 504, 0, 2649, 2650, 3, 983, 491, 0, 2650, 2651, 3, 1001, 500, 0, 2651, - 2652, 3, 979, 489, 0, 2652, 2653, 3, 983, 491, 0, 2653, 2654, 3, 1011, - 505, 0, 2654, 2655, 3, 983, 491, 0, 2655, 2656, 3, 1013, 506, 0, 2656, - 2657, 3, 1011, 505, 0, 2657, 2658, 3, 983, 491, 0, 2658, 2659, 3, 997, - 498, 0, 2659, 2660, 3, 983, 491, 0, 2660, 2661, 3, 979, 489, 0, 2661, 2662, - 3, 1013, 506, 0, 2662, 2663, 3, 1003, 501, 0, 2663, 2664, 3, 1009, 504, - 0, 2664, 350, 1, 0, 0, 0, 2665, 2666, 3, 985, 492, 0, 2666, 2667, 3, 991, - 495, 0, 2667, 2668, 3, 997, 498, 0, 2668, 2669, 3, 983, 491, 0, 2669, 2670, - 3, 991, 495, 0, 2670, 2671, 3, 1001, 500, 0, 2671, 2672, 3, 1005, 502, - 0, 2672, 2673, 3, 1015, 507, 0, 2673, 2674, 3, 1013, 506, 0, 2674, 352, - 1, 0, 0, 0, 2675, 2676, 3, 991, 495, 0, 2676, 2677, 3, 999, 499, 0, 2677, - 2678, 3, 975, 487, 0, 2678, 2679, 3, 987, 493, 0, 2679, 2680, 3, 983, 491, - 0, 2680, 2681, 3, 991, 495, 0, 2681, 2682, 3, 1001, 500, 0, 2682, 2683, - 3, 1005, 502, 0, 2683, 2684, 3, 1015, 507, 0, 2684, 2685, 3, 1013, 506, - 0, 2685, 354, 1, 0, 0, 0, 2686, 2687, 3, 979, 489, 0, 2687, 2688, 3, 1015, - 507, 0, 2688, 2689, 3, 1011, 505, 0, 2689, 2690, 3, 1013, 506, 0, 2690, - 2691, 3, 1003, 501, 0, 2691, 2692, 3, 999, 499, 0, 2692, 2693, 3, 1019, - 509, 0, 2693, 2694, 3, 991, 495, 0, 2694, 2695, 3, 981, 490, 0, 2695, 2696, - 3, 987, 493, 0, 2696, 2697, 3, 983, 491, 0, 2697, 2698, 3, 1013, 506, 0, - 2698, 356, 1, 0, 0, 0, 2699, 2700, 3, 1013, 506, 0, 2700, 2701, 3, 983, - 491, 0, 2701, 2702, 3, 1021, 510, 0, 2702, 2703, 3, 1013, 506, 0, 2703, - 2704, 3, 985, 492, 0, 2704, 2705, 3, 991, 495, 0, 2705, 2706, 3, 997, 498, - 0, 2706, 2707, 3, 1013, 506, 0, 2707, 2708, 3, 983, 491, 0, 2708, 2709, - 3, 1009, 504, 0, 2709, 358, 1, 0, 0, 0, 2710, 2711, 3, 1001, 500, 0, 2711, - 2712, 3, 1015, 507, 0, 2712, 2713, 3, 999, 499, 0, 2713, 2714, 3, 977, - 488, 0, 2714, 2715, 3, 983, 491, 0, 2715, 2716, 3, 1009, 504, 0, 2716, - 2717, 3, 985, 492, 0, 2717, 2718, 3, 991, 495, 0, 2718, 2719, 3, 997, 498, - 0, 2719, 2720, 3, 1013, 506, 0, 2720, 2721, 3, 983, 491, 0, 2721, 2722, - 3, 1009, 504, 0, 2722, 360, 1, 0, 0, 0, 2723, 2724, 3, 981, 490, 0, 2724, - 2725, 3, 1009, 504, 0, 2725, 2726, 3, 1003, 501, 0, 2726, 2727, 3, 1005, - 502, 0, 2727, 2728, 3, 981, 490, 0, 2728, 2729, 3, 1003, 501, 0, 2729, - 2730, 3, 1019, 509, 0, 2730, 2731, 3, 1001, 500, 0, 2731, 2732, 3, 985, - 492, 0, 2732, 2733, 3, 991, 495, 0, 2733, 2734, 3, 997, 498, 0, 2734, 2735, - 3, 1013, 506, 0, 2735, 2736, 3, 983, 491, 0, 2736, 2737, 3, 1009, 504, - 0, 2737, 362, 1, 0, 0, 0, 2738, 2739, 3, 981, 490, 0, 2739, 2740, 3, 975, - 487, 0, 2740, 2741, 3, 1013, 506, 0, 2741, 2742, 3, 983, 491, 0, 2742, - 2743, 3, 985, 492, 0, 2743, 2744, 3, 991, 495, 0, 2744, 2745, 3, 997, 498, - 0, 2745, 2746, 3, 1013, 506, 0, 2746, 2747, 3, 983, 491, 0, 2747, 2748, - 3, 1009, 504, 0, 2748, 364, 1, 0, 0, 0, 2749, 2750, 3, 985, 492, 0, 2750, - 2751, 3, 991, 495, 0, 2751, 2752, 3, 997, 498, 0, 2752, 2753, 3, 1013, - 506, 0, 2753, 2754, 3, 983, 491, 0, 2754, 2755, 3, 1009, 504, 0, 2755, - 366, 1, 0, 0, 0, 2756, 2757, 3, 1019, 509, 0, 2757, 2758, 3, 991, 495, - 0, 2758, 2759, 3, 981, 490, 0, 2759, 2760, 3, 987, 493, 0, 2760, 2761, - 3, 983, 491, 0, 2761, 2762, 3, 1013, 506, 0, 2762, 368, 1, 0, 0, 0, 2763, - 2764, 3, 1019, 509, 0, 2764, 2765, 3, 991, 495, 0, 2765, 2766, 3, 981, - 490, 0, 2766, 2767, 3, 987, 493, 0, 2767, 2768, 3, 983, 491, 0, 2768, 2769, - 3, 1013, 506, 0, 2769, 2770, 3, 1011, 505, 0, 2770, 370, 1, 0, 0, 0, 2771, - 2772, 3, 979, 489, 0, 2772, 2773, 3, 975, 487, 0, 2773, 2774, 3, 1005, - 502, 0, 2774, 2775, 3, 1013, 506, 0, 2775, 2776, 3, 991, 495, 0, 2776, - 2777, 3, 1003, 501, 0, 2777, 2778, 3, 1001, 500, 0, 2778, 372, 1, 0, 0, - 0, 2779, 2780, 3, 991, 495, 0, 2780, 2781, 3, 979, 489, 0, 2781, 2782, - 3, 1003, 501, 0, 2782, 2783, 3, 1001, 500, 0, 2783, 374, 1, 0, 0, 0, 2784, - 2785, 3, 1013, 506, 0, 2785, 2786, 3, 1003, 501, 0, 2786, 2787, 3, 1003, - 501, 0, 2787, 2788, 3, 997, 498, 0, 2788, 2789, 3, 1013, 506, 0, 2789, - 2790, 3, 991, 495, 0, 2790, 2791, 3, 1005, 502, 0, 2791, 376, 1, 0, 0, - 0, 2792, 2793, 3, 981, 490, 0, 2793, 2794, 3, 975, 487, 0, 2794, 2795, - 3, 1013, 506, 0, 2795, 2796, 3, 975, 487, 0, 2796, 2797, 3, 1011, 505, - 0, 2797, 2798, 3, 1003, 501, 0, 2798, 2799, 3, 1015, 507, 0, 2799, 2800, - 3, 1009, 504, 0, 2800, 2801, 3, 979, 489, 0, 2801, 2802, 3, 983, 491, 0, - 2802, 378, 1, 0, 0, 0, 2803, 2804, 3, 1011, 505, 0, 2804, 2805, 3, 1003, - 501, 0, 2805, 2806, 3, 1015, 507, 0, 2806, 2807, 3, 1009, 504, 0, 2807, - 2808, 3, 979, 489, 0, 2808, 2809, 3, 983, 491, 0, 2809, 380, 1, 0, 0, 0, - 2810, 2811, 3, 1011, 505, 0, 2811, 2812, 3, 983, 491, 0, 2812, 2813, 3, - 997, 498, 0, 2813, 2814, 3, 983, 491, 0, 2814, 2815, 3, 979, 489, 0, 2815, - 2816, 3, 1013, 506, 0, 2816, 2817, 3, 991, 495, 0, 2817, 2818, 3, 1003, - 501, 0, 2818, 2819, 3, 1001, 500, 0, 2819, 382, 1, 0, 0, 0, 2820, 2821, - 3, 985, 492, 0, 2821, 2822, 3, 1003, 501, 0, 2822, 2823, 3, 1003, 501, - 0, 2823, 2824, 3, 1013, 506, 0, 2824, 2825, 3, 983, 491, 0, 2825, 2826, - 3, 1009, 504, 0, 2826, 384, 1, 0, 0, 0, 2827, 2828, 3, 989, 494, 0, 2828, - 2829, 3, 983, 491, 0, 2829, 2830, 3, 975, 487, 0, 2830, 2831, 3, 981, 490, - 0, 2831, 2832, 3, 983, 491, 0, 2832, 2833, 3, 1009, 504, 0, 2833, 386, - 1, 0, 0, 0, 2834, 2835, 3, 979, 489, 0, 2835, 2836, 3, 1003, 501, 0, 2836, - 2837, 3, 1001, 500, 0, 2837, 2838, 3, 1013, 506, 0, 2838, 2839, 3, 983, - 491, 0, 2839, 2840, 3, 1001, 500, 0, 2840, 2841, 3, 1013, 506, 0, 2841, - 388, 1, 0, 0, 0, 2842, 2843, 3, 1009, 504, 0, 2843, 2844, 3, 983, 491, - 0, 2844, 2845, 3, 1001, 500, 0, 2845, 2846, 3, 981, 490, 0, 2846, 2847, - 3, 983, 491, 0, 2847, 2848, 3, 1009, 504, 0, 2848, 2849, 3, 999, 499, 0, - 2849, 2850, 3, 1003, 501, 0, 2850, 2851, 3, 981, 490, 0, 2851, 2852, 3, - 983, 491, 0, 2852, 390, 1, 0, 0, 0, 2853, 2854, 3, 977, 488, 0, 2854, 2855, - 3, 991, 495, 0, 2855, 2856, 3, 1001, 500, 0, 2856, 2857, 3, 981, 490, 0, - 2857, 2858, 3, 1011, 505, 0, 2858, 392, 1, 0, 0, 0, 2859, 2860, 3, 975, - 487, 0, 2860, 2861, 3, 1013, 506, 0, 2861, 2862, 3, 1013, 506, 0, 2862, - 2863, 3, 1009, 504, 0, 2863, 394, 1, 0, 0, 0, 2864, 2865, 3, 979, 489, - 0, 2865, 2866, 3, 1003, 501, 0, 2866, 2867, 3, 1001, 500, 0, 2867, 2868, - 3, 1013, 506, 0, 2868, 2869, 3, 983, 491, 0, 2869, 2870, 3, 1001, 500, - 0, 2870, 2871, 3, 1013, 506, 0, 2871, 2872, 3, 1005, 502, 0, 2872, 2873, - 3, 975, 487, 0, 2873, 2874, 3, 1009, 504, 0, 2874, 2875, 3, 975, 487, 0, - 2875, 2876, 3, 999, 499, 0, 2876, 2877, 3, 1011, 505, 0, 2877, 396, 1, - 0, 0, 0, 2878, 2879, 3, 979, 489, 0, 2879, 2880, 3, 975, 487, 0, 2880, - 2881, 3, 1005, 502, 0, 2881, 2882, 3, 1013, 506, 0, 2882, 2883, 3, 991, - 495, 0, 2883, 2884, 3, 1003, 501, 0, 2884, 2885, 3, 1001, 500, 0, 2885, - 2886, 3, 1005, 502, 0, 2886, 2887, 3, 975, 487, 0, 2887, 2888, 3, 1009, - 504, 0, 2888, 2889, 3, 975, 487, 0, 2889, 2890, 3, 999, 499, 0, 2890, 2891, - 3, 1011, 505, 0, 2891, 398, 1, 0, 0, 0, 2892, 2893, 3, 1005, 502, 0, 2893, - 2894, 3, 975, 487, 0, 2894, 2895, 3, 1009, 504, 0, 2895, 2896, 3, 975, - 487, 0, 2896, 2897, 3, 999, 499, 0, 2897, 2898, 3, 1011, 505, 0, 2898, - 400, 1, 0, 0, 0, 2899, 2900, 3, 1017, 508, 0, 2900, 2901, 3, 975, 487, - 0, 2901, 2902, 3, 1009, 504, 0, 2902, 2903, 3, 991, 495, 0, 2903, 2904, - 3, 975, 487, 0, 2904, 2905, 3, 977, 488, 0, 2905, 2906, 3, 997, 498, 0, - 2906, 2907, 3, 983, 491, 0, 2907, 2908, 3, 1011, 505, 0, 2908, 402, 1, - 0, 0, 0, 2909, 2910, 3, 981, 490, 0, 2910, 2911, 3, 983, 491, 0, 2911, - 2912, 3, 1011, 505, 0, 2912, 2913, 3, 995, 497, 0, 2913, 2914, 3, 1013, - 506, 0, 2914, 2915, 3, 1003, 501, 0, 2915, 2916, 3, 1005, 502, 0, 2916, - 2917, 3, 1019, 509, 0, 2917, 2918, 3, 991, 495, 0, 2918, 2919, 3, 981, - 490, 0, 2919, 2920, 3, 1013, 506, 0, 2920, 2921, 3, 989, 494, 0, 2921, - 404, 1, 0, 0, 0, 2922, 2923, 3, 979, 489, 0, 2923, 2924, 3, 997, 498, 0, - 2924, 2925, 3, 975, 487, 0, 2925, 2926, 3, 1011, 505, 0, 2926, 2927, 3, - 1011, 505, 0, 2927, 406, 1, 0, 0, 0, 2928, 2929, 3, 1011, 505, 0, 2929, - 2930, 3, 1013, 506, 0, 2930, 2931, 3, 1023, 511, 0, 2931, 2932, 3, 997, - 498, 0, 2932, 2933, 3, 983, 491, 0, 2933, 408, 1, 0, 0, 0, 2934, 2935, - 3, 977, 488, 0, 2935, 2936, 3, 1015, 507, 0, 2936, 2937, 3, 1013, 506, - 0, 2937, 2938, 3, 1013, 506, 0, 2938, 2939, 3, 1003, 501, 0, 2939, 2940, - 3, 1001, 500, 0, 2940, 2941, 3, 1011, 505, 0, 2941, 2942, 3, 1013, 506, - 0, 2942, 2943, 3, 1023, 511, 0, 2943, 2944, 3, 997, 498, 0, 2944, 2945, - 3, 983, 491, 0, 2945, 410, 1, 0, 0, 0, 2946, 2947, 3, 981, 490, 0, 2947, - 2948, 3, 983, 491, 0, 2948, 2949, 3, 1011, 505, 0, 2949, 2950, 3, 991, - 495, 0, 2950, 2951, 3, 987, 493, 0, 2951, 2952, 3, 1001, 500, 0, 2952, - 412, 1, 0, 0, 0, 2953, 2954, 3, 1005, 502, 0, 2954, 2955, 3, 1009, 504, - 0, 2955, 2956, 3, 1003, 501, 0, 2956, 2957, 3, 1005, 502, 0, 2957, 2958, - 3, 983, 491, 0, 2958, 2959, 3, 1009, 504, 0, 2959, 2960, 3, 1013, 506, - 0, 2960, 2961, 3, 991, 495, 0, 2961, 2962, 3, 983, 491, 0, 2962, 2963, - 3, 1011, 505, 0, 2963, 414, 1, 0, 0, 0, 2964, 2965, 3, 981, 490, 0, 2965, - 2966, 3, 983, 491, 0, 2966, 2967, 3, 1011, 505, 0, 2967, 2968, 3, 991, - 495, 0, 2968, 2969, 3, 987, 493, 0, 2969, 2970, 3, 1001, 500, 0, 2970, - 2971, 3, 1005, 502, 0, 2971, 2972, 3, 1009, 504, 0, 2972, 2973, 3, 1003, - 501, 0, 2973, 2974, 3, 1005, 502, 0, 2974, 2975, 3, 983, 491, 0, 2975, - 2976, 3, 1009, 504, 0, 2976, 2977, 3, 1013, 506, 0, 2977, 2978, 3, 991, - 495, 0, 2978, 2979, 3, 983, 491, 0, 2979, 2980, 3, 1011, 505, 0, 2980, - 416, 1, 0, 0, 0, 2981, 2982, 3, 1011, 505, 0, 2982, 2983, 3, 1013, 506, - 0, 2983, 2984, 3, 1023, 511, 0, 2984, 2985, 3, 997, 498, 0, 2985, 2986, - 3, 991, 495, 0, 2986, 2987, 3, 1001, 500, 0, 2987, 2988, 3, 987, 493, 0, - 2988, 418, 1, 0, 0, 0, 2989, 2990, 3, 979, 489, 0, 2990, 2991, 3, 997, - 498, 0, 2991, 2992, 3, 983, 491, 0, 2992, 2993, 3, 975, 487, 0, 2993, 2994, - 3, 1009, 504, 0, 2994, 420, 1, 0, 0, 0, 2995, 2996, 3, 1019, 509, 0, 2996, - 2997, 3, 991, 495, 0, 2997, 2998, 3, 981, 490, 0, 2998, 2999, 3, 1013, - 506, 0, 2999, 3000, 3, 989, 494, 0, 3000, 422, 1, 0, 0, 0, 3001, 3002, - 3, 989, 494, 0, 3002, 3003, 3, 983, 491, 0, 3003, 3004, 3, 991, 495, 0, - 3004, 3005, 3, 987, 493, 0, 3005, 3006, 3, 989, 494, 0, 3006, 3007, 3, - 1013, 506, 0, 3007, 424, 1, 0, 0, 0, 3008, 3009, 3, 975, 487, 0, 3009, - 3010, 3, 1015, 507, 0, 3010, 3011, 3, 1013, 506, 0, 3011, 3012, 3, 1003, - 501, 0, 3012, 3013, 3, 985, 492, 0, 3013, 3014, 3, 991, 495, 0, 3014, 3015, - 3, 997, 498, 0, 3015, 3016, 3, 997, 498, 0, 3016, 426, 1, 0, 0, 0, 3017, - 3018, 3, 1015, 507, 0, 3018, 3019, 3, 1009, 504, 0, 3019, 3020, 3, 997, - 498, 0, 3020, 428, 1, 0, 0, 0, 3021, 3022, 3, 985, 492, 0, 3022, 3023, - 3, 1003, 501, 0, 3023, 3024, 3, 997, 498, 0, 3024, 3025, 3, 981, 490, 0, - 3025, 3026, 3, 983, 491, 0, 3026, 3027, 3, 1009, 504, 0, 3027, 430, 1, - 0, 0, 0, 3028, 3029, 3, 1005, 502, 0, 3029, 3030, 3, 975, 487, 0, 3030, - 3031, 3, 1011, 505, 0, 3031, 3032, 3, 1011, 505, 0, 3032, 3033, 3, 991, - 495, 0, 3033, 3034, 3, 1001, 500, 0, 3034, 3035, 3, 987, 493, 0, 3035, - 432, 1, 0, 0, 0, 3036, 3037, 3, 979, 489, 0, 3037, 3038, 3, 1003, 501, - 0, 3038, 3039, 3, 1001, 500, 0, 3039, 3040, 3, 1013, 506, 0, 3040, 3041, - 3, 983, 491, 0, 3041, 3042, 3, 1021, 510, 0, 3042, 3043, 3, 1013, 506, - 0, 3043, 434, 1, 0, 0, 0, 3044, 3045, 3, 983, 491, 0, 3045, 3046, 3, 981, - 490, 0, 3046, 3047, 3, 991, 495, 0, 3047, 3048, 3, 1013, 506, 0, 3048, - 3049, 3, 975, 487, 0, 3049, 3050, 3, 977, 488, 0, 3050, 3051, 3, 997, 498, - 0, 3051, 3052, 3, 983, 491, 0, 3052, 436, 1, 0, 0, 0, 3053, 3054, 3, 1009, - 504, 0, 3054, 3055, 3, 983, 491, 0, 3055, 3056, 3, 975, 487, 0, 3056, 3057, - 3, 981, 490, 0, 3057, 3058, 3, 1003, 501, 0, 3058, 3059, 3, 1001, 500, - 0, 3059, 3060, 3, 997, 498, 0, 3060, 3061, 3, 1023, 511, 0, 3061, 438, - 1, 0, 0, 0, 3062, 3063, 3, 975, 487, 0, 3063, 3064, 3, 1013, 506, 0, 3064, - 3065, 3, 1013, 506, 0, 3065, 3066, 3, 1009, 504, 0, 3066, 3067, 3, 991, - 495, 0, 3067, 3068, 3, 977, 488, 0, 3068, 3069, 3, 1015, 507, 0, 3069, - 3070, 3, 1013, 506, 0, 3070, 3071, 3, 983, 491, 0, 3071, 3072, 3, 1011, - 505, 0, 3072, 440, 1, 0, 0, 0, 3073, 3074, 3, 985, 492, 0, 3074, 3075, - 3, 991, 495, 0, 3075, 3076, 3, 997, 498, 0, 3076, 3077, 3, 1013, 506, 0, - 3077, 3078, 3, 983, 491, 0, 3078, 3079, 3, 1009, 504, 0, 3079, 3080, 3, - 1013, 506, 0, 3080, 3081, 3, 1023, 511, 0, 3081, 3082, 3, 1005, 502, 0, - 3082, 3083, 3, 983, 491, 0, 3083, 442, 1, 0, 0, 0, 3084, 3085, 3, 991, - 495, 0, 3085, 3086, 3, 999, 499, 0, 3086, 3087, 3, 975, 487, 0, 3087, 3088, - 3, 987, 493, 0, 3088, 3089, 3, 983, 491, 0, 3089, 444, 1, 0, 0, 0, 3090, - 3091, 3, 1011, 505, 0, 3091, 3092, 3, 1013, 506, 0, 3092, 3093, 3, 975, - 487, 0, 3093, 3094, 3, 1013, 506, 0, 3094, 3095, 3, 991, 495, 0, 3095, - 3096, 3, 979, 489, 0, 3096, 3097, 3, 991, 495, 0, 3097, 3098, 3, 999, 499, - 0, 3098, 3099, 3, 975, 487, 0, 3099, 3100, 3, 987, 493, 0, 3100, 3101, - 3, 983, 491, 0, 3101, 446, 1, 0, 0, 0, 3102, 3103, 3, 981, 490, 0, 3103, - 3104, 3, 1023, 511, 0, 3104, 3105, 3, 1001, 500, 0, 3105, 3106, 3, 975, - 487, 0, 3106, 3107, 3, 999, 499, 0, 3107, 3108, 3, 991, 495, 0, 3108, 3109, - 3, 979, 489, 0, 3109, 3110, 3, 991, 495, 0, 3110, 3111, 3, 999, 499, 0, - 3111, 3112, 3, 975, 487, 0, 3112, 3113, 3, 987, 493, 0, 3113, 3114, 3, - 983, 491, 0, 3114, 448, 1, 0, 0, 0, 3115, 3116, 3, 979, 489, 0, 3116, 3117, - 3, 1015, 507, 0, 3117, 3118, 3, 1011, 505, 0, 3118, 3119, 3, 1013, 506, - 0, 3119, 3120, 3, 1003, 501, 0, 3120, 3121, 3, 999, 499, 0, 3121, 3122, - 3, 979, 489, 0, 3122, 3123, 3, 1003, 501, 0, 3123, 3124, 3, 1001, 500, - 0, 3124, 3125, 3, 1013, 506, 0, 3125, 3126, 3, 975, 487, 0, 3126, 3127, - 3, 991, 495, 0, 3127, 3128, 3, 1001, 500, 0, 3128, 3129, 3, 983, 491, 0, - 3129, 3130, 3, 1009, 504, 0, 3130, 450, 1, 0, 0, 0, 3131, 3132, 3, 987, - 493, 0, 3132, 3133, 3, 1009, 504, 0, 3133, 3134, 3, 1003, 501, 0, 3134, - 3135, 3, 1015, 507, 0, 3135, 3136, 3, 1005, 502, 0, 3136, 3137, 3, 977, - 488, 0, 3137, 3138, 3, 1003, 501, 0, 3138, 3139, 3, 1021, 510, 0, 3139, - 452, 1, 0, 0, 0, 3140, 3141, 3, 1017, 508, 0, 3141, 3142, 3, 991, 495, - 0, 3142, 3143, 3, 1011, 505, 0, 3143, 3144, 3, 991, 495, 0, 3144, 3145, - 3, 977, 488, 0, 3145, 3146, 3, 997, 498, 0, 3146, 3147, 3, 983, 491, 0, - 3147, 454, 1, 0, 0, 0, 3148, 3149, 3, 1011, 505, 0, 3149, 3150, 3, 975, - 487, 0, 3150, 3151, 3, 1017, 508, 0, 3151, 3152, 3, 983, 491, 0, 3152, - 3153, 3, 979, 489, 0, 3153, 3154, 3, 989, 494, 0, 3154, 3155, 3, 975, 487, - 0, 3155, 3156, 3, 1001, 500, 0, 3156, 3157, 3, 987, 493, 0, 3157, 3158, - 3, 983, 491, 0, 3158, 3159, 3, 1011, 505, 0, 3159, 456, 1, 0, 0, 0, 3160, - 3161, 3, 1011, 505, 0, 3161, 3162, 3, 975, 487, 0, 3162, 3163, 3, 1017, - 508, 0, 3163, 3164, 3, 983, 491, 0, 3164, 3165, 5, 95, 0, 0, 3165, 3166, - 3, 979, 489, 0, 3166, 3167, 3, 989, 494, 0, 3167, 3168, 3, 975, 487, 0, - 3168, 3169, 3, 1001, 500, 0, 3169, 3170, 3, 987, 493, 0, 3170, 3171, 3, - 983, 491, 0, 3171, 3172, 3, 1011, 505, 0, 3172, 458, 1, 0, 0, 0, 3173, - 3174, 3, 979, 489, 0, 3174, 3175, 3, 975, 487, 0, 3175, 3176, 3, 1001, - 500, 0, 3176, 3177, 3, 979, 489, 0, 3177, 3178, 3, 983, 491, 0, 3178, 3179, - 3, 997, 498, 0, 3179, 3180, 5, 95, 0, 0, 3180, 3181, 3, 979, 489, 0, 3181, - 3182, 3, 989, 494, 0, 3182, 3183, 3, 975, 487, 0, 3183, 3184, 3, 1001, - 500, 0, 3184, 3185, 3, 987, 493, 0, 3185, 3186, 3, 983, 491, 0, 3186, 3187, - 3, 1011, 505, 0, 3187, 460, 1, 0, 0, 0, 3188, 3189, 3, 979, 489, 0, 3189, - 3190, 3, 997, 498, 0, 3190, 3191, 3, 1003, 501, 0, 3191, 3192, 3, 1011, - 505, 0, 3192, 3193, 3, 983, 491, 0, 3193, 3194, 5, 95, 0, 0, 3194, 3195, - 3, 1005, 502, 0, 3195, 3196, 3, 975, 487, 0, 3196, 3197, 3, 987, 493, 0, - 3197, 3198, 3, 983, 491, 0, 3198, 462, 1, 0, 0, 0, 3199, 3200, 3, 1011, - 505, 0, 3200, 3201, 3, 989, 494, 0, 3201, 3202, 3, 1003, 501, 0, 3202, - 3203, 3, 1019, 509, 0, 3203, 3204, 5, 95, 0, 0, 3204, 3205, 3, 1005, 502, - 0, 3205, 3206, 3, 975, 487, 0, 3206, 3207, 3, 987, 493, 0, 3207, 3208, - 3, 983, 491, 0, 3208, 464, 1, 0, 0, 0, 3209, 3210, 3, 981, 490, 0, 3210, - 3211, 3, 983, 491, 0, 3211, 3212, 3, 997, 498, 0, 3212, 3213, 3, 983, 491, - 0, 3213, 3214, 3, 1013, 506, 0, 3214, 3215, 3, 983, 491, 0, 3215, 3216, - 5, 95, 0, 0, 3216, 3217, 3, 975, 487, 0, 3217, 3218, 3, 979, 489, 0, 3218, - 3219, 3, 1013, 506, 0, 3219, 3220, 3, 991, 495, 0, 3220, 3221, 3, 1003, - 501, 0, 3221, 3222, 3, 1001, 500, 0, 3222, 466, 1, 0, 0, 0, 3223, 3224, - 3, 981, 490, 0, 3224, 3225, 3, 983, 491, 0, 3225, 3226, 3, 997, 498, 0, - 3226, 3227, 3, 983, 491, 0, 3227, 3228, 3, 1013, 506, 0, 3228, 3229, 3, - 983, 491, 0, 3229, 3230, 5, 95, 0, 0, 3230, 3231, 3, 1003, 501, 0, 3231, - 3232, 3, 977, 488, 0, 3232, 3233, 3, 993, 496, 0, 3233, 3234, 3, 983, 491, - 0, 3234, 3235, 3, 979, 489, 0, 3235, 3236, 3, 1013, 506, 0, 3236, 468, - 1, 0, 0, 0, 3237, 3238, 3, 979, 489, 0, 3238, 3239, 3, 1009, 504, 0, 3239, - 3240, 3, 983, 491, 0, 3240, 3241, 3, 975, 487, 0, 3241, 3242, 3, 1013, - 506, 0, 3242, 3243, 3, 983, 491, 0, 3243, 3244, 5, 95, 0, 0, 3244, 3245, - 3, 1003, 501, 0, 3245, 3246, 3, 977, 488, 0, 3246, 3247, 3, 993, 496, 0, - 3247, 3248, 3, 983, 491, 0, 3248, 3249, 3, 979, 489, 0, 3249, 3250, 3, - 1013, 506, 0, 3250, 470, 1, 0, 0, 0, 3251, 3252, 3, 979, 489, 0, 3252, - 3253, 3, 975, 487, 0, 3253, 3254, 3, 997, 498, 0, 3254, 3255, 3, 997, 498, - 0, 3255, 3256, 5, 95, 0, 0, 3256, 3257, 3, 999, 499, 0, 3257, 3258, 3, - 991, 495, 0, 3258, 3259, 3, 979, 489, 0, 3259, 3260, 3, 1009, 504, 0, 3260, - 3261, 3, 1003, 501, 0, 3261, 3262, 3, 985, 492, 0, 3262, 3263, 3, 997, - 498, 0, 3263, 3264, 3, 1003, 501, 0, 3264, 3265, 3, 1019, 509, 0, 3265, - 472, 1, 0, 0, 0, 3266, 3267, 3, 979, 489, 0, 3267, 3268, 3, 975, 487, 0, - 3268, 3269, 3, 997, 498, 0, 3269, 3270, 3, 997, 498, 0, 3270, 3271, 5, - 95, 0, 0, 3271, 3272, 3, 1001, 500, 0, 3272, 3273, 3, 975, 487, 0, 3273, - 3274, 3, 1001, 500, 0, 3274, 3275, 3, 1003, 501, 0, 3275, 3276, 3, 985, - 492, 0, 3276, 3277, 3, 997, 498, 0, 3277, 3278, 3, 1003, 501, 0, 3278, - 3279, 3, 1019, 509, 0, 3279, 474, 1, 0, 0, 0, 3280, 3281, 3, 1003, 501, - 0, 3281, 3282, 3, 1005, 502, 0, 3282, 3283, 3, 983, 491, 0, 3283, 3284, - 3, 1001, 500, 0, 3284, 3285, 5, 95, 0, 0, 3285, 3286, 3, 997, 498, 0, 3286, - 3287, 3, 991, 495, 0, 3287, 3288, 3, 1001, 500, 0, 3288, 3289, 3, 995, - 497, 0, 3289, 476, 1, 0, 0, 0, 3290, 3291, 3, 1011, 505, 0, 3291, 3292, - 3, 991, 495, 0, 3292, 3293, 3, 987, 493, 0, 3293, 3294, 3, 1001, 500, 0, - 3294, 3295, 5, 95, 0, 0, 3295, 3296, 3, 1003, 501, 0, 3296, 3297, 3, 1015, - 507, 0, 3297, 3298, 3, 1013, 506, 0, 3298, 478, 1, 0, 0, 0, 3299, 3300, - 3, 979, 489, 0, 3300, 3301, 3, 975, 487, 0, 3301, 3302, 3, 1001, 500, 0, - 3302, 3303, 3, 979, 489, 0, 3303, 3304, 3, 983, 491, 0, 3304, 3305, 3, - 997, 498, 0, 3305, 480, 1, 0, 0, 0, 3306, 3307, 3, 1005, 502, 0, 3307, - 3308, 3, 1009, 504, 0, 3308, 3309, 3, 991, 495, 0, 3309, 3310, 3, 999, - 499, 0, 3310, 3311, 3, 975, 487, 0, 3311, 3312, 3, 1009, 504, 0, 3312, - 3313, 3, 1023, 511, 0, 3313, 482, 1, 0, 0, 0, 3314, 3315, 3, 1011, 505, - 0, 3315, 3316, 3, 1015, 507, 0, 3316, 3317, 3, 979, 489, 0, 3317, 3318, - 3, 979, 489, 0, 3318, 3319, 3, 983, 491, 0, 3319, 3320, 3, 1011, 505, 0, - 3320, 3321, 3, 1011, 505, 0, 3321, 484, 1, 0, 0, 0, 3322, 3323, 3, 981, - 490, 0, 3323, 3324, 3, 975, 487, 0, 3324, 3325, 3, 1001, 500, 0, 3325, - 3326, 3, 987, 493, 0, 3326, 3327, 3, 983, 491, 0, 3327, 3328, 3, 1009, - 504, 0, 3328, 486, 1, 0, 0, 0, 3329, 3330, 3, 1019, 509, 0, 3330, 3331, - 3, 975, 487, 0, 3331, 3332, 3, 1009, 504, 0, 3332, 3333, 3, 1001, 500, - 0, 3333, 3334, 3, 991, 495, 0, 3334, 3335, 3, 1001, 500, 0, 3335, 3336, - 3, 987, 493, 0, 3336, 488, 1, 0, 0, 0, 3337, 3338, 3, 991, 495, 0, 3338, - 3339, 3, 1001, 500, 0, 3339, 3340, 3, 985, 492, 0, 3340, 3341, 3, 1003, - 501, 0, 3341, 490, 1, 0, 0, 0, 3342, 3343, 3, 1013, 506, 0, 3343, 3344, - 3, 983, 491, 0, 3344, 3345, 3, 999, 499, 0, 3345, 3346, 3, 1005, 502, 0, - 3346, 3347, 3, 997, 498, 0, 3347, 3348, 3, 975, 487, 0, 3348, 3349, 3, - 1013, 506, 0, 3349, 3350, 3, 983, 491, 0, 3350, 492, 1, 0, 0, 0, 3351, - 3352, 3, 1003, 501, 0, 3352, 3353, 3, 1001, 500, 0, 3353, 3354, 3, 979, - 489, 0, 3354, 3355, 3, 997, 498, 0, 3355, 3356, 3, 991, 495, 0, 3356, 3357, - 3, 979, 489, 0, 3357, 3358, 3, 995, 497, 0, 3358, 494, 1, 0, 0, 0, 3359, - 3360, 3, 1003, 501, 0, 3360, 3361, 3, 1001, 500, 0, 3361, 3362, 3, 979, - 489, 0, 3362, 3363, 3, 989, 494, 0, 3363, 3364, 3, 975, 487, 0, 3364, 3365, - 3, 1001, 500, 0, 3365, 3366, 3, 987, 493, 0, 3366, 3367, 3, 983, 491, 0, - 3367, 496, 1, 0, 0, 0, 3368, 3369, 3, 1013, 506, 0, 3369, 3370, 3, 975, - 487, 0, 3370, 3371, 3, 977, 488, 0, 3371, 3372, 3, 991, 495, 0, 3372, 3373, - 3, 1001, 500, 0, 3373, 3374, 3, 981, 490, 0, 3374, 3375, 3, 983, 491, 0, - 3375, 3376, 3, 1021, 510, 0, 3376, 498, 1, 0, 0, 0, 3377, 3378, 3, 989, - 494, 0, 3378, 3379, 5, 49, 0, 0, 3379, 500, 1, 0, 0, 0, 3380, 3381, 3, - 989, 494, 0, 3381, 3382, 5, 50, 0, 0, 3382, 502, 1, 0, 0, 0, 3383, 3384, - 3, 989, 494, 0, 3384, 3385, 5, 51, 0, 0, 3385, 504, 1, 0, 0, 0, 3386, 3387, - 3, 989, 494, 0, 3387, 3388, 5, 52, 0, 0, 3388, 506, 1, 0, 0, 0, 3389, 3390, - 3, 989, 494, 0, 3390, 3391, 5, 53, 0, 0, 3391, 508, 1, 0, 0, 0, 3392, 3393, - 3, 989, 494, 0, 3393, 3394, 5, 54, 0, 0, 3394, 510, 1, 0, 0, 0, 3395, 3396, - 3, 1005, 502, 0, 3396, 3397, 3, 975, 487, 0, 3397, 3398, 3, 1009, 504, - 0, 3398, 3399, 3, 975, 487, 0, 3399, 3400, 3, 987, 493, 0, 3400, 3401, - 3, 1009, 504, 0, 3401, 3402, 3, 975, 487, 0, 3402, 3403, 3, 1005, 502, - 0, 3403, 3404, 3, 989, 494, 0, 3404, 512, 1, 0, 0, 0, 3405, 3406, 3, 1011, - 505, 0, 3406, 3407, 3, 1013, 506, 0, 3407, 3408, 3, 1009, 504, 0, 3408, - 3409, 3, 991, 495, 0, 3409, 3410, 3, 1001, 500, 0, 3410, 3411, 3, 987, - 493, 0, 3411, 514, 1, 0, 0, 0, 3412, 3413, 3, 991, 495, 0, 3413, 3414, - 3, 1001, 500, 0, 3414, 3415, 3, 1013, 506, 0, 3415, 3416, 3, 983, 491, - 0, 3416, 3417, 3, 987, 493, 0, 3417, 3418, 3, 983, 491, 0, 3418, 3419, - 3, 1009, 504, 0, 3419, 516, 1, 0, 0, 0, 3420, 3421, 3, 997, 498, 0, 3421, - 3422, 3, 1003, 501, 0, 3422, 3423, 3, 1001, 500, 0, 3423, 3424, 3, 987, - 493, 0, 3424, 518, 1, 0, 0, 0, 3425, 3426, 3, 981, 490, 0, 3426, 3427, - 3, 983, 491, 0, 3427, 3428, 3, 979, 489, 0, 3428, 3429, 3, 991, 495, 0, - 3429, 3430, 3, 999, 499, 0, 3430, 3431, 3, 975, 487, 0, 3431, 3432, 3, - 997, 498, 0, 3432, 520, 1, 0, 0, 0, 3433, 3434, 3, 977, 488, 0, 3434, 3435, - 3, 1003, 501, 0, 3435, 3436, 3, 1003, 501, 0, 3436, 3437, 3, 997, 498, - 0, 3437, 3438, 3, 983, 491, 0, 3438, 3439, 3, 975, 487, 0, 3439, 3440, - 3, 1001, 500, 0, 3440, 522, 1, 0, 0, 0, 3441, 3442, 3, 981, 490, 0, 3442, - 3443, 3, 975, 487, 0, 3443, 3444, 3, 1013, 506, 0, 3444, 3445, 3, 983, - 491, 0, 3445, 3446, 3, 1013, 506, 0, 3446, 3447, 3, 991, 495, 0, 3447, - 3448, 3, 999, 499, 0, 3448, 3449, 3, 983, 491, 0, 3449, 524, 1, 0, 0, 0, - 3450, 3451, 3, 981, 490, 0, 3451, 3452, 3, 975, 487, 0, 3452, 3453, 3, - 1013, 506, 0, 3453, 3454, 3, 983, 491, 0, 3454, 526, 1, 0, 0, 0, 3455, - 3456, 3, 975, 487, 0, 3456, 3457, 3, 1015, 507, 0, 3457, 3458, 3, 1013, - 506, 0, 3458, 3459, 3, 1003, 501, 0, 3459, 3460, 3, 1001, 500, 0, 3460, - 3461, 3, 1015, 507, 0, 3461, 3462, 3, 999, 499, 0, 3462, 3463, 3, 977, - 488, 0, 3463, 3464, 3, 983, 491, 0, 3464, 3465, 3, 1009, 504, 0, 3465, - 528, 1, 0, 0, 0, 3466, 3467, 3, 977, 488, 0, 3467, 3468, 3, 991, 495, 0, - 3468, 3469, 3, 1001, 500, 0, 3469, 3470, 3, 975, 487, 0, 3470, 3471, 3, - 1009, 504, 0, 3471, 3472, 3, 1023, 511, 0, 3472, 530, 1, 0, 0, 0, 3473, - 3474, 3, 989, 494, 0, 3474, 3475, 3, 975, 487, 0, 3475, 3476, 3, 1011, - 505, 0, 3476, 3477, 3, 989, 494, 0, 3477, 3478, 3, 983, 491, 0, 3478, 3479, - 3, 981, 490, 0, 3479, 3480, 3, 1011, 505, 0, 3480, 3481, 3, 1013, 506, - 0, 3481, 3482, 3, 1009, 504, 0, 3482, 3483, 3, 991, 495, 0, 3483, 3484, - 3, 1001, 500, 0, 3484, 3485, 3, 987, 493, 0, 3485, 532, 1, 0, 0, 0, 3486, - 3487, 3, 979, 489, 0, 3487, 3488, 3, 1015, 507, 0, 3488, 3489, 3, 1009, - 504, 0, 3489, 3490, 3, 1009, 504, 0, 3490, 3491, 3, 983, 491, 0, 3491, - 3492, 3, 1001, 500, 0, 3492, 3493, 3, 979, 489, 0, 3493, 3494, 3, 1023, - 511, 0, 3494, 534, 1, 0, 0, 0, 3495, 3496, 3, 985, 492, 0, 3496, 3497, - 3, 997, 498, 0, 3497, 3498, 3, 1003, 501, 0, 3498, 3499, 3, 975, 487, 0, - 3499, 3500, 3, 1013, 506, 0, 3500, 536, 1, 0, 0, 0, 3501, 3502, 3, 1011, - 505, 0, 3502, 3503, 3, 1013, 506, 0, 3503, 3504, 3, 1009, 504, 0, 3504, - 3505, 3, 991, 495, 0, 3505, 3506, 3, 1001, 500, 0, 3506, 3507, 3, 987, - 493, 0, 3507, 3508, 3, 1013, 506, 0, 3508, 3509, 3, 983, 491, 0, 3509, - 3510, 3, 999, 499, 0, 3510, 3511, 3, 1005, 502, 0, 3511, 3512, 3, 997, - 498, 0, 3512, 3513, 3, 975, 487, 0, 3513, 3514, 3, 1013, 506, 0, 3514, - 3515, 3, 983, 491, 0, 3515, 538, 1, 0, 0, 0, 3516, 3517, 3, 983, 491, 0, - 3517, 3518, 3, 1001, 500, 0, 3518, 3519, 3, 1015, 507, 0, 3519, 3520, 3, - 999, 499, 0, 3520, 540, 1, 0, 0, 0, 3521, 3522, 3, 979, 489, 0, 3522, 3523, - 3, 1003, 501, 0, 3523, 3524, 3, 1015, 507, 0, 3524, 3525, 3, 1001, 500, - 0, 3525, 3526, 3, 1013, 506, 0, 3526, 542, 1, 0, 0, 0, 3527, 3528, 3, 1011, - 505, 0, 3528, 3529, 3, 1015, 507, 0, 3529, 3530, 3, 999, 499, 0, 3530, - 544, 1, 0, 0, 0, 3531, 3532, 3, 975, 487, 0, 3532, 3533, 3, 1017, 508, - 0, 3533, 3534, 3, 987, 493, 0, 3534, 546, 1, 0, 0, 0, 3535, 3536, 3, 999, - 499, 0, 3536, 3537, 3, 991, 495, 0, 3537, 3538, 3, 1001, 500, 0, 3538, - 548, 1, 0, 0, 0, 3539, 3540, 3, 999, 499, 0, 3540, 3541, 3, 975, 487, 0, - 3541, 3542, 3, 1021, 510, 0, 3542, 550, 1, 0, 0, 0, 3543, 3544, 3, 997, - 498, 0, 3544, 3545, 3, 983, 491, 0, 3545, 3546, 3, 1001, 500, 0, 3546, - 3547, 3, 987, 493, 0, 3547, 3548, 3, 1013, 506, 0, 3548, 3549, 3, 989, - 494, 0, 3549, 552, 1, 0, 0, 0, 3550, 3551, 3, 1013, 506, 0, 3551, 3552, - 3, 1009, 504, 0, 3552, 3553, 3, 991, 495, 0, 3553, 3554, 3, 999, 499, 0, - 3554, 554, 1, 0, 0, 0, 3555, 3556, 3, 979, 489, 0, 3556, 3557, 3, 1003, - 501, 0, 3557, 3558, 3, 975, 487, 0, 3558, 3559, 3, 997, 498, 0, 3559, 3560, - 3, 983, 491, 0, 3560, 3561, 3, 1011, 505, 0, 3561, 3562, 3, 979, 489, 0, - 3562, 3563, 3, 983, 491, 0, 3563, 556, 1, 0, 0, 0, 3564, 3565, 3, 979, - 489, 0, 3565, 3566, 3, 975, 487, 0, 3566, 3567, 3, 1011, 505, 0, 3567, - 3568, 3, 1013, 506, 0, 3568, 558, 1, 0, 0, 0, 3569, 3570, 3, 975, 487, - 0, 3570, 3571, 3, 1001, 500, 0, 3571, 3572, 3, 981, 490, 0, 3572, 560, - 1, 0, 0, 0, 3573, 3574, 3, 1003, 501, 0, 3574, 3575, 3, 1009, 504, 0, 3575, - 562, 1, 0, 0, 0, 3576, 3577, 3, 1001, 500, 0, 3577, 3578, 3, 1003, 501, - 0, 3578, 3579, 3, 1013, 506, 0, 3579, 564, 1, 0, 0, 0, 3580, 3581, 3, 1001, - 500, 0, 3581, 3582, 3, 1015, 507, 0, 3582, 3583, 3, 997, 498, 0, 3583, - 3584, 3, 997, 498, 0, 3584, 566, 1, 0, 0, 0, 3585, 3586, 3, 991, 495, 0, - 3586, 3587, 3, 1001, 500, 0, 3587, 568, 1, 0, 0, 0, 3588, 3589, 3, 977, - 488, 0, 3589, 3590, 3, 983, 491, 0, 3590, 3591, 3, 1013, 506, 0, 3591, - 3592, 3, 1019, 509, 0, 3592, 3593, 3, 983, 491, 0, 3593, 3594, 3, 983, - 491, 0, 3594, 3595, 3, 1001, 500, 0, 3595, 570, 1, 0, 0, 0, 3596, 3597, - 3, 997, 498, 0, 3597, 3598, 3, 991, 495, 0, 3598, 3599, 3, 995, 497, 0, - 3599, 3600, 3, 983, 491, 0, 3600, 572, 1, 0, 0, 0, 3601, 3602, 3, 999, - 499, 0, 3602, 3603, 3, 975, 487, 0, 3603, 3604, 3, 1013, 506, 0, 3604, - 3605, 3, 979, 489, 0, 3605, 3606, 3, 989, 494, 0, 3606, 574, 1, 0, 0, 0, - 3607, 3608, 3, 983, 491, 0, 3608, 3609, 3, 1021, 510, 0, 3609, 3610, 3, - 991, 495, 0, 3610, 3611, 3, 1011, 505, 0, 3611, 3612, 3, 1013, 506, 0, - 3612, 3613, 3, 1011, 505, 0, 3613, 576, 1, 0, 0, 0, 3614, 3615, 3, 1015, - 507, 0, 3615, 3616, 3, 1001, 500, 0, 3616, 3617, 3, 991, 495, 0, 3617, - 3618, 3, 1007, 503, 0, 3618, 3619, 3, 1015, 507, 0, 3619, 3620, 3, 983, - 491, 0, 3620, 578, 1, 0, 0, 0, 3621, 3622, 3, 981, 490, 0, 3622, 3623, - 3, 983, 491, 0, 3623, 3624, 3, 985, 492, 0, 3624, 3625, 3, 975, 487, 0, - 3625, 3626, 3, 1015, 507, 0, 3626, 3627, 3, 997, 498, 0, 3627, 3628, 3, - 1013, 506, 0, 3628, 580, 1, 0, 0, 0, 3629, 3630, 3, 1013, 506, 0, 3630, - 3631, 3, 1009, 504, 0, 3631, 3632, 3, 1015, 507, 0, 3632, 3633, 3, 983, - 491, 0, 3633, 582, 1, 0, 0, 0, 3634, 3635, 3, 985, 492, 0, 3635, 3636, - 3, 975, 487, 0, 3636, 3637, 3, 997, 498, 0, 3637, 3638, 3, 1011, 505, 0, - 3638, 3639, 3, 983, 491, 0, 3639, 584, 1, 0, 0, 0, 3640, 3641, 3, 1017, - 508, 0, 3641, 3642, 3, 975, 487, 0, 3642, 3643, 3, 997, 498, 0, 3643, 3644, - 3, 991, 495, 0, 3644, 3645, 3, 981, 490, 0, 3645, 3646, 3, 975, 487, 0, - 3646, 3647, 3, 1013, 506, 0, 3647, 3648, 3, 991, 495, 0, 3648, 3649, 3, - 1003, 501, 0, 3649, 3650, 3, 1001, 500, 0, 3650, 586, 1, 0, 0, 0, 3651, - 3652, 3, 985, 492, 0, 3652, 3653, 3, 983, 491, 0, 3653, 3654, 3, 983, 491, - 0, 3654, 3655, 3, 981, 490, 0, 3655, 3656, 3, 977, 488, 0, 3656, 3657, - 3, 975, 487, 0, 3657, 3658, 3, 979, 489, 0, 3658, 3659, 3, 995, 497, 0, - 3659, 588, 1, 0, 0, 0, 3660, 3661, 3, 1009, 504, 0, 3661, 3662, 3, 1015, - 507, 0, 3662, 3663, 3, 997, 498, 0, 3663, 3664, 3, 983, 491, 0, 3664, 590, - 1, 0, 0, 0, 3665, 3666, 3, 1009, 504, 0, 3666, 3667, 3, 983, 491, 0, 3667, - 3668, 3, 1007, 503, 0, 3668, 3669, 3, 1015, 507, 0, 3669, 3670, 3, 991, - 495, 0, 3670, 3671, 3, 1009, 504, 0, 3671, 3672, 3, 983, 491, 0, 3672, - 3673, 3, 981, 490, 0, 3673, 592, 1, 0, 0, 0, 3674, 3675, 3, 983, 491, 0, - 3675, 3676, 3, 1009, 504, 0, 3676, 3677, 3, 1009, 504, 0, 3677, 3678, 3, - 1003, 501, 0, 3678, 3679, 3, 1009, 504, 0, 3679, 594, 1, 0, 0, 0, 3680, - 3681, 3, 1009, 504, 0, 3681, 3682, 3, 975, 487, 0, 3682, 3683, 3, 991, - 495, 0, 3683, 3684, 3, 1011, 505, 0, 3684, 3685, 3, 983, 491, 0, 3685, - 596, 1, 0, 0, 0, 3686, 3687, 3, 1009, 504, 0, 3687, 3688, 3, 975, 487, - 0, 3688, 3689, 3, 1001, 500, 0, 3689, 3690, 3, 987, 493, 0, 3690, 3691, - 3, 983, 491, 0, 3691, 598, 1, 0, 0, 0, 3692, 3693, 3, 1009, 504, 0, 3693, - 3694, 3, 983, 491, 0, 3694, 3695, 3, 987, 493, 0, 3695, 3696, 3, 983, 491, - 0, 3696, 3697, 3, 1021, 510, 0, 3697, 600, 1, 0, 0, 0, 3698, 3699, 3, 1005, - 502, 0, 3699, 3700, 3, 975, 487, 0, 3700, 3701, 3, 1013, 506, 0, 3701, - 3702, 3, 1013, 506, 0, 3702, 3703, 3, 983, 491, 0, 3703, 3704, 3, 1009, - 504, 0, 3704, 3705, 3, 1001, 500, 0, 3705, 602, 1, 0, 0, 0, 3706, 3707, - 3, 983, 491, 0, 3707, 3708, 3, 1021, 510, 0, 3708, 3709, 3, 1005, 502, - 0, 3709, 3710, 3, 1009, 504, 0, 3710, 3711, 3, 983, 491, 0, 3711, 3712, - 3, 1011, 505, 0, 3712, 3713, 3, 1011, 505, 0, 3713, 3714, 3, 991, 495, - 0, 3714, 3715, 3, 1003, 501, 0, 3715, 3716, 3, 1001, 500, 0, 3716, 604, - 1, 0, 0, 0, 3717, 3718, 3, 1021, 510, 0, 3718, 3719, 3, 1005, 502, 0, 3719, - 3720, 3, 975, 487, 0, 3720, 3721, 3, 1013, 506, 0, 3721, 3722, 3, 989, - 494, 0, 3722, 606, 1, 0, 0, 0, 3723, 3724, 3, 979, 489, 0, 3724, 3725, - 3, 1003, 501, 0, 3725, 3726, 3, 1001, 500, 0, 3726, 3727, 3, 1011, 505, - 0, 3727, 3728, 3, 1013, 506, 0, 3728, 3729, 3, 1009, 504, 0, 3729, 3730, - 3, 975, 487, 0, 3730, 3731, 3, 991, 495, 0, 3731, 3732, 3, 1001, 500, 0, - 3732, 3733, 3, 1013, 506, 0, 3733, 608, 1, 0, 0, 0, 3734, 3735, 3, 1009, - 504, 0, 3735, 3736, 3, 983, 491, 0, 3736, 3737, 3, 1011, 505, 0, 3737, - 3738, 3, 1013, 506, 0, 3738, 610, 1, 0, 0, 0, 3739, 3740, 3, 1011, 505, - 0, 3740, 3741, 3, 983, 491, 0, 3741, 3742, 3, 1009, 504, 0, 3742, 3743, - 3, 1017, 508, 0, 3743, 3744, 3, 991, 495, 0, 3744, 3745, 3, 979, 489, 0, - 3745, 3746, 3, 983, 491, 0, 3746, 612, 1, 0, 0, 0, 3747, 3748, 3, 1011, - 505, 0, 3748, 3749, 3, 983, 491, 0, 3749, 3750, 3, 1009, 504, 0, 3750, - 3751, 3, 1017, 508, 0, 3751, 3752, 3, 991, 495, 0, 3752, 3753, 3, 979, - 489, 0, 3753, 3754, 3, 983, 491, 0, 3754, 3755, 3, 1011, 505, 0, 3755, - 614, 1, 0, 0, 0, 3756, 3757, 3, 1003, 501, 0, 3757, 3758, 3, 981, 490, - 0, 3758, 3759, 3, 975, 487, 0, 3759, 3760, 3, 1013, 506, 0, 3760, 3761, - 3, 975, 487, 0, 3761, 616, 1, 0, 0, 0, 3762, 3763, 3, 977, 488, 0, 3763, - 3764, 3, 975, 487, 0, 3764, 3765, 3, 1011, 505, 0, 3765, 3766, 3, 983, - 491, 0, 3766, 618, 1, 0, 0, 0, 3767, 3768, 3, 975, 487, 0, 3768, 3769, - 3, 1015, 507, 0, 3769, 3770, 3, 1013, 506, 0, 3770, 3771, 3, 989, 494, - 0, 3771, 620, 1, 0, 0, 0, 3772, 3773, 3, 975, 487, 0, 3773, 3774, 3, 1015, - 507, 0, 3774, 3775, 3, 1013, 506, 0, 3775, 3776, 3, 989, 494, 0, 3776, - 3777, 3, 983, 491, 0, 3777, 3778, 3, 1001, 500, 0, 3778, 3779, 3, 1013, - 506, 0, 3779, 3780, 3, 991, 495, 0, 3780, 3781, 3, 979, 489, 0, 3781, 3782, - 3, 975, 487, 0, 3782, 3783, 3, 1013, 506, 0, 3783, 3784, 3, 991, 495, 0, - 3784, 3785, 3, 1003, 501, 0, 3785, 3786, 3, 1001, 500, 0, 3786, 622, 1, - 0, 0, 0, 3787, 3788, 3, 977, 488, 0, 3788, 3789, 3, 975, 487, 0, 3789, - 3790, 3, 1011, 505, 0, 3790, 3791, 3, 991, 495, 0, 3791, 3792, 3, 979, - 489, 0, 3792, 624, 1, 0, 0, 0, 3793, 3794, 3, 1001, 500, 0, 3794, 3795, - 3, 1003, 501, 0, 3795, 3796, 3, 1013, 506, 0, 3796, 3797, 3, 989, 494, - 0, 3797, 3798, 3, 991, 495, 0, 3798, 3799, 3, 1001, 500, 0, 3799, 3800, - 3, 987, 493, 0, 3800, 626, 1, 0, 0, 0, 3801, 3802, 3, 1003, 501, 0, 3802, - 3803, 3, 975, 487, 0, 3803, 3804, 3, 1015, 507, 0, 3804, 3805, 3, 1013, - 506, 0, 3805, 3806, 3, 989, 494, 0, 3806, 628, 1, 0, 0, 0, 3807, 3808, - 3, 1003, 501, 0, 3808, 3809, 3, 1005, 502, 0, 3809, 3810, 3, 983, 491, - 0, 3810, 3811, 3, 1009, 504, 0, 3811, 3812, 3, 975, 487, 0, 3812, 3813, - 3, 1013, 506, 0, 3813, 3814, 3, 991, 495, 0, 3814, 3815, 3, 1003, 501, - 0, 3815, 3816, 3, 1001, 500, 0, 3816, 630, 1, 0, 0, 0, 3817, 3818, 3, 999, - 499, 0, 3818, 3819, 3, 983, 491, 0, 3819, 3820, 3, 1013, 506, 0, 3820, - 3821, 3, 989, 494, 0, 3821, 3822, 3, 1003, 501, 0, 3822, 3823, 3, 981, - 490, 0, 3823, 632, 1, 0, 0, 0, 3824, 3825, 3, 1005, 502, 0, 3825, 3826, - 3, 975, 487, 0, 3826, 3827, 3, 1013, 506, 0, 3827, 3828, 3, 989, 494, 0, - 3828, 634, 1, 0, 0, 0, 3829, 3830, 3, 1013, 506, 0, 3830, 3831, 3, 991, - 495, 0, 3831, 3832, 3, 999, 499, 0, 3832, 3833, 3, 983, 491, 0, 3833, 3834, - 3, 1003, 501, 0, 3834, 3835, 3, 1015, 507, 0, 3835, 3836, 3, 1013, 506, - 0, 3836, 636, 1, 0, 0, 0, 3837, 3838, 3, 977, 488, 0, 3838, 3839, 3, 1003, - 501, 0, 3839, 3840, 3, 981, 490, 0, 3840, 3841, 3, 1023, 511, 0, 3841, - 638, 1, 0, 0, 0, 3842, 3843, 3, 1009, 504, 0, 3843, 3844, 3, 983, 491, - 0, 3844, 3845, 3, 1011, 505, 0, 3845, 3846, 3, 1005, 502, 0, 3846, 3847, - 3, 1003, 501, 0, 3847, 3848, 3, 1001, 500, 0, 3848, 3849, 3, 1011, 505, - 0, 3849, 3850, 3, 983, 491, 0, 3850, 640, 1, 0, 0, 0, 3851, 3852, 3, 1009, - 504, 0, 3852, 3853, 3, 983, 491, 0, 3853, 3854, 3, 1007, 503, 0, 3854, - 3855, 3, 1015, 507, 0, 3855, 3856, 3, 983, 491, 0, 3856, 3857, 3, 1011, - 505, 0, 3857, 3858, 3, 1013, 506, 0, 3858, 642, 1, 0, 0, 0, 3859, 3860, - 3, 993, 496, 0, 3860, 3861, 3, 1011, 505, 0, 3861, 3862, 3, 1003, 501, - 0, 3862, 3863, 3, 1001, 500, 0, 3863, 644, 1, 0, 0, 0, 3864, 3865, 3, 1021, - 510, 0, 3865, 3866, 3, 999, 499, 0, 3866, 3867, 3, 997, 498, 0, 3867, 646, - 1, 0, 0, 0, 3868, 3869, 3, 1011, 505, 0, 3869, 3870, 3, 1013, 506, 0, 3870, - 3871, 3, 975, 487, 0, 3871, 3872, 3, 1013, 506, 0, 3872, 3873, 3, 1015, - 507, 0, 3873, 3874, 3, 1011, 505, 0, 3874, 648, 1, 0, 0, 0, 3875, 3876, - 3, 1017, 508, 0, 3876, 3877, 3, 983, 491, 0, 3877, 3878, 3, 1009, 504, - 0, 3878, 3879, 3, 1011, 505, 0, 3879, 3880, 3, 991, 495, 0, 3880, 3881, - 3, 1003, 501, 0, 3881, 3882, 3, 1001, 500, 0, 3882, 650, 1, 0, 0, 0, 3883, - 3884, 3, 987, 493, 0, 3884, 3885, 3, 983, 491, 0, 3885, 3886, 3, 1013, - 506, 0, 3886, 652, 1, 0, 0, 0, 3887, 3888, 3, 1005, 502, 0, 3888, 3889, - 3, 1003, 501, 0, 3889, 3890, 3, 1011, 505, 0, 3890, 3891, 3, 1013, 506, - 0, 3891, 654, 1, 0, 0, 0, 3892, 3893, 3, 1005, 502, 0, 3893, 3894, 3, 1015, - 507, 0, 3894, 3895, 3, 1013, 506, 0, 3895, 656, 1, 0, 0, 0, 3896, 3897, - 3, 1005, 502, 0, 3897, 3898, 3, 975, 487, 0, 3898, 3899, 3, 1013, 506, - 0, 3899, 3900, 3, 979, 489, 0, 3900, 3901, 3, 989, 494, 0, 3901, 658, 1, - 0, 0, 0, 3902, 3903, 3, 975, 487, 0, 3903, 3904, 3, 1005, 502, 0, 3904, - 3905, 3, 991, 495, 0, 3905, 660, 1, 0, 0, 0, 3906, 3907, 3, 979, 489, 0, - 3907, 3908, 3, 997, 498, 0, 3908, 3909, 3, 991, 495, 0, 3909, 3910, 3, - 983, 491, 0, 3910, 3911, 3, 1001, 500, 0, 3911, 3912, 3, 1013, 506, 0, - 3912, 662, 1, 0, 0, 0, 3913, 3914, 3, 979, 489, 0, 3914, 3915, 3, 997, - 498, 0, 3915, 3916, 3, 991, 495, 0, 3916, 3917, 3, 983, 491, 0, 3917, 3918, - 3, 1001, 500, 0, 3918, 3919, 3, 1013, 506, 0, 3919, 3920, 3, 1011, 505, - 0, 3920, 664, 1, 0, 0, 0, 3921, 3922, 3, 1005, 502, 0, 3922, 3923, 3, 1015, - 507, 0, 3923, 3924, 3, 977, 488, 0, 3924, 3925, 3, 997, 498, 0, 3925, 3926, - 3, 991, 495, 0, 3926, 3927, 3, 1011, 505, 0, 3927, 3928, 3, 989, 494, 0, - 3928, 666, 1, 0, 0, 0, 3929, 3930, 3, 983, 491, 0, 3930, 3931, 3, 1021, - 510, 0, 3931, 3932, 3, 1005, 502, 0, 3932, 3933, 3, 1003, 501, 0, 3933, - 3934, 3, 1011, 505, 0, 3934, 3935, 3, 983, 491, 0, 3935, 668, 1, 0, 0, - 0, 3936, 3937, 3, 1001, 500, 0, 3937, 3938, 3, 975, 487, 0, 3938, 3939, - 3, 999, 499, 0, 3939, 3940, 3, 983, 491, 0, 3940, 3941, 3, 1011, 505, 0, - 3941, 3942, 3, 1005, 502, 0, 3942, 3943, 3, 975, 487, 0, 3943, 3944, 3, - 979, 489, 0, 3944, 3945, 3, 983, 491, 0, 3945, 670, 1, 0, 0, 0, 3946, 3947, - 3, 1011, 505, 0, 3947, 3948, 3, 983, 491, 0, 3948, 3949, 3, 1011, 505, - 0, 3949, 3950, 3, 1011, 505, 0, 3950, 3951, 3, 991, 495, 0, 3951, 3952, - 3, 1003, 501, 0, 3952, 3953, 3, 1001, 500, 0, 3953, 672, 1, 0, 0, 0, 3954, - 3955, 3, 987, 493, 0, 3955, 3956, 3, 1015, 507, 0, 3956, 3957, 3, 983, - 491, 0, 3957, 3958, 3, 1011, 505, 0, 3958, 3959, 3, 1013, 506, 0, 3959, - 674, 1, 0, 0, 0, 3960, 3961, 3, 1005, 502, 0, 3961, 3962, 3, 975, 487, - 0, 3962, 3963, 3, 987, 493, 0, 3963, 3964, 3, 991, 495, 0, 3964, 3965, - 3, 1001, 500, 0, 3965, 3966, 3, 987, 493, 0, 3966, 676, 1, 0, 0, 0, 3967, - 3968, 3, 1001, 500, 0, 3968, 3969, 3, 1003, 501, 0, 3969, 3970, 3, 1013, - 506, 0, 3970, 3971, 5, 95, 0, 0, 3971, 3972, 3, 1011, 505, 0, 3972, 3973, - 3, 1015, 507, 0, 3973, 3974, 3, 1005, 502, 0, 3974, 3975, 3, 1005, 502, - 0, 3975, 3976, 3, 1003, 501, 0, 3976, 3977, 3, 1009, 504, 0, 3977, 3978, - 3, 1013, 506, 0, 3978, 3979, 3, 983, 491, 0, 3979, 3980, 3, 981, 490, 0, - 3980, 678, 1, 0, 0, 0, 3981, 3982, 3, 1015, 507, 0, 3982, 3983, 3, 1011, - 505, 0, 3983, 3984, 3, 983, 491, 0, 3984, 3985, 3, 1009, 504, 0, 3985, - 3986, 3, 1001, 500, 0, 3986, 3987, 3, 975, 487, 0, 3987, 3988, 3, 999, - 499, 0, 3988, 3989, 3, 983, 491, 0, 3989, 680, 1, 0, 0, 0, 3990, 3991, - 3, 1005, 502, 0, 3991, 3992, 3, 975, 487, 0, 3992, 3993, 3, 1011, 505, - 0, 3993, 3994, 3, 1011, 505, 0, 3994, 3995, 3, 1019, 509, 0, 3995, 3996, - 3, 1003, 501, 0, 3996, 3997, 3, 1009, 504, 0, 3997, 3998, 3, 981, 490, - 0, 3998, 682, 1, 0, 0, 0, 3999, 4000, 3, 979, 489, 0, 4000, 4001, 3, 1003, - 501, 0, 4001, 4002, 3, 1001, 500, 0, 4002, 4003, 3, 1001, 500, 0, 4003, - 4004, 3, 983, 491, 0, 4004, 4005, 3, 979, 489, 0, 4005, 4006, 3, 1013, - 506, 0, 4006, 4007, 3, 991, 495, 0, 4007, 4008, 3, 1003, 501, 0, 4008, - 4009, 3, 1001, 500, 0, 4009, 684, 1, 0, 0, 0, 4010, 4011, 3, 981, 490, - 0, 4011, 4012, 3, 975, 487, 0, 4012, 4013, 3, 1013, 506, 0, 4013, 4014, - 3, 975, 487, 0, 4014, 4015, 3, 977, 488, 0, 4015, 4016, 3, 975, 487, 0, - 4016, 4017, 3, 1011, 505, 0, 4017, 4018, 3, 983, 491, 0, 4018, 686, 1, - 0, 0, 0, 4019, 4020, 3, 1007, 503, 0, 4020, 4021, 3, 1015, 507, 0, 4021, - 4022, 3, 983, 491, 0, 4022, 4023, 3, 1009, 504, 0, 4023, 4024, 3, 1023, - 511, 0, 4024, 688, 1, 0, 0, 0, 4025, 4026, 3, 999, 499, 0, 4026, 4027, - 3, 975, 487, 0, 4027, 4028, 3, 1005, 502, 0, 4028, 690, 1, 0, 0, 0, 4029, - 4030, 3, 999, 499, 0, 4030, 4031, 3, 975, 487, 0, 4031, 4032, 3, 1005, - 502, 0, 4032, 4033, 3, 1005, 502, 0, 4033, 4034, 3, 991, 495, 0, 4034, - 4035, 3, 1001, 500, 0, 4035, 4036, 3, 987, 493, 0, 4036, 692, 1, 0, 0, - 0, 4037, 4038, 3, 991, 495, 0, 4038, 4039, 3, 999, 499, 0, 4039, 4040, - 3, 1005, 502, 0, 4040, 4041, 3, 1003, 501, 0, 4041, 4042, 3, 1009, 504, - 0, 4042, 4043, 3, 1013, 506, 0, 4043, 694, 1, 0, 0, 0, 4044, 4045, 3, 991, - 495, 0, 4045, 4046, 3, 1001, 500, 0, 4046, 4047, 3, 1013, 506, 0, 4047, - 4048, 3, 1003, 501, 0, 4048, 696, 1, 0, 0, 0, 4049, 4050, 3, 977, 488, - 0, 4050, 4051, 3, 975, 487, 0, 4051, 4052, 3, 1013, 506, 0, 4052, 4053, - 3, 979, 489, 0, 4053, 4054, 3, 989, 494, 0, 4054, 698, 1, 0, 0, 0, 4055, - 4056, 3, 997, 498, 0, 4056, 4057, 3, 991, 495, 0, 4057, 4058, 3, 1001, - 500, 0, 4058, 4059, 3, 995, 497, 0, 4059, 700, 1, 0, 0, 0, 4060, 4061, - 3, 983, 491, 0, 4061, 4062, 3, 1021, 510, 0, 4062, 4063, 3, 1005, 502, - 0, 4063, 4064, 3, 1003, 501, 0, 4064, 4065, 3, 1009, 504, 0, 4065, 4066, - 3, 1013, 506, 0, 4066, 702, 1, 0, 0, 0, 4067, 4068, 3, 987, 493, 0, 4068, - 4069, 3, 983, 491, 0, 4069, 4070, 3, 1001, 500, 0, 4070, 4071, 3, 983, - 491, 0, 4071, 4072, 3, 1009, 504, 0, 4072, 4073, 3, 975, 487, 0, 4073, - 4074, 3, 1013, 506, 0, 4074, 4075, 3, 983, 491, 0, 4075, 704, 1, 0, 0, - 0, 4076, 4077, 3, 979, 489, 0, 4077, 4078, 3, 1003, 501, 0, 4078, 4079, - 3, 1001, 500, 0, 4079, 4080, 3, 1001, 500, 0, 4080, 4081, 3, 983, 491, - 0, 4081, 4082, 3, 979, 489, 0, 4082, 4083, 3, 1013, 506, 0, 4083, 4084, - 3, 1003, 501, 0, 4084, 4085, 3, 1009, 504, 0, 4085, 706, 1, 0, 0, 0, 4086, - 4087, 3, 983, 491, 0, 4087, 4088, 3, 1021, 510, 0, 4088, 4089, 3, 983, - 491, 0, 4089, 4090, 3, 979, 489, 0, 4090, 708, 1, 0, 0, 0, 4091, 4092, - 3, 1013, 506, 0, 4092, 4093, 3, 975, 487, 0, 4093, 4094, 3, 977, 488, 0, - 4094, 4095, 3, 997, 498, 0, 4095, 4096, 3, 983, 491, 0, 4096, 4097, 3, - 1011, 505, 0, 4097, 710, 1, 0, 0, 0, 4098, 4099, 3, 1017, 508, 0, 4099, - 4100, 3, 991, 495, 0, 4100, 4101, 3, 983, 491, 0, 4101, 4102, 3, 1019, - 509, 0, 4102, 4103, 3, 1011, 505, 0, 4103, 712, 1, 0, 0, 0, 4104, 4105, - 3, 983, 491, 0, 4105, 4106, 3, 1021, 510, 0, 4106, 4107, 3, 1005, 502, - 0, 4107, 4108, 3, 1003, 501, 0, 4108, 4109, 3, 1011, 505, 0, 4109, 4110, - 3, 983, 491, 0, 4110, 4111, 3, 981, 490, 0, 4111, 714, 1, 0, 0, 0, 4112, - 4113, 3, 1005, 502, 0, 4113, 4114, 3, 975, 487, 0, 4114, 4115, 3, 1009, - 504, 0, 4115, 4116, 3, 975, 487, 0, 4116, 4117, 3, 999, 499, 0, 4117, 4118, - 3, 983, 491, 0, 4118, 4119, 3, 1013, 506, 0, 4119, 4120, 3, 983, 491, 0, - 4120, 4121, 3, 1009, 504, 0, 4121, 716, 1, 0, 0, 0, 4122, 4123, 3, 1005, - 502, 0, 4123, 4124, 3, 975, 487, 0, 4124, 4125, 3, 1009, 504, 0, 4125, - 4126, 3, 975, 487, 0, 4126, 4127, 3, 999, 499, 0, 4127, 4128, 3, 983, 491, - 0, 4128, 4129, 3, 1013, 506, 0, 4129, 4130, 3, 983, 491, 0, 4130, 4131, - 3, 1009, 504, 0, 4131, 4132, 3, 1011, 505, 0, 4132, 718, 1, 0, 0, 0, 4133, - 4134, 3, 989, 494, 0, 4134, 4135, 3, 983, 491, 0, 4135, 4136, 3, 975, 487, - 0, 4136, 4137, 3, 981, 490, 0, 4137, 4138, 3, 983, 491, 0, 4138, 4139, - 3, 1009, 504, 0, 4139, 4140, 3, 1011, 505, 0, 4140, 720, 1, 0, 0, 0, 4141, - 4142, 3, 1001, 500, 0, 4142, 4143, 3, 975, 487, 0, 4143, 4144, 3, 1017, - 508, 0, 4144, 4145, 3, 991, 495, 0, 4145, 4146, 3, 987, 493, 0, 4146, 4147, - 3, 975, 487, 0, 4147, 4148, 3, 1013, 506, 0, 4148, 4149, 3, 991, 495, 0, - 4149, 4150, 3, 1003, 501, 0, 4150, 4151, 3, 1001, 500, 0, 4151, 722, 1, - 0, 0, 0, 4152, 4153, 3, 999, 499, 0, 4153, 4154, 3, 983, 491, 0, 4154, - 4155, 3, 1001, 500, 0, 4155, 4156, 3, 1015, 507, 0, 4156, 724, 1, 0, 0, - 0, 4157, 4158, 3, 989, 494, 0, 4158, 4159, 3, 1003, 501, 0, 4159, 4160, - 3, 999, 499, 0, 4160, 4161, 3, 983, 491, 0, 4161, 4162, 3, 1011, 505, 0, - 4162, 726, 1, 0, 0, 0, 4163, 4164, 3, 989, 494, 0, 4164, 4165, 3, 1003, - 501, 0, 4165, 4166, 3, 999, 499, 0, 4166, 4167, 3, 983, 491, 0, 4167, 728, - 1, 0, 0, 0, 4168, 4169, 3, 997, 498, 0, 4169, 4170, 3, 1003, 501, 0, 4170, - 4171, 3, 987, 493, 0, 4171, 4172, 3, 991, 495, 0, 4172, 4173, 3, 1001, - 500, 0, 4173, 730, 1, 0, 0, 0, 4174, 4175, 3, 985, 492, 0, 4175, 4176, - 3, 1003, 501, 0, 4176, 4177, 3, 1015, 507, 0, 4177, 4178, 3, 1001, 500, - 0, 4178, 4179, 3, 981, 490, 0, 4179, 732, 1, 0, 0, 0, 4180, 4181, 3, 999, - 499, 0, 4181, 4182, 3, 1003, 501, 0, 4182, 4183, 3, 981, 490, 0, 4183, - 4184, 3, 1015, 507, 0, 4184, 4185, 3, 997, 498, 0, 4185, 4186, 3, 983, - 491, 0, 4186, 4187, 3, 1011, 505, 0, 4187, 734, 1, 0, 0, 0, 4188, 4189, - 3, 983, 491, 0, 4189, 4190, 3, 1001, 500, 0, 4190, 4191, 3, 1013, 506, - 0, 4191, 4192, 3, 991, 495, 0, 4192, 4193, 3, 1013, 506, 0, 4193, 4194, - 3, 991, 495, 0, 4194, 4195, 3, 983, 491, 0, 4195, 4196, 3, 1011, 505, 0, - 4196, 736, 1, 0, 0, 0, 4197, 4198, 3, 975, 487, 0, 4198, 4199, 3, 1011, - 505, 0, 4199, 4200, 3, 1011, 505, 0, 4200, 4201, 3, 1003, 501, 0, 4201, - 4202, 3, 979, 489, 0, 4202, 4203, 3, 991, 495, 0, 4203, 4204, 3, 975, 487, - 0, 4204, 4205, 3, 1013, 506, 0, 4205, 4206, 3, 991, 495, 0, 4206, 4207, - 3, 1003, 501, 0, 4207, 4208, 3, 1001, 500, 0, 4208, 4209, 3, 1011, 505, - 0, 4209, 738, 1, 0, 0, 0, 4210, 4211, 3, 999, 499, 0, 4211, 4212, 3, 991, - 495, 0, 4212, 4213, 3, 979, 489, 0, 4213, 4214, 3, 1009, 504, 0, 4214, - 4215, 3, 1003, 501, 0, 4215, 4216, 3, 985, 492, 0, 4216, 4217, 3, 997, - 498, 0, 4217, 4218, 3, 1003, 501, 0, 4218, 4219, 3, 1019, 509, 0, 4219, - 4220, 3, 1011, 505, 0, 4220, 740, 1, 0, 0, 0, 4221, 4222, 3, 1001, 500, - 0, 4222, 4223, 3, 975, 487, 0, 4223, 4224, 3, 1001, 500, 0, 4224, 4225, - 3, 1003, 501, 0, 4225, 4226, 3, 985, 492, 0, 4226, 4227, 3, 997, 498, 0, - 4227, 4228, 3, 1003, 501, 0, 4228, 4229, 3, 1019, 509, 0, 4229, 4230, 3, - 1011, 505, 0, 4230, 742, 1, 0, 0, 0, 4231, 4232, 3, 1019, 509, 0, 4232, - 4233, 3, 1003, 501, 0, 4233, 4234, 3, 1009, 504, 0, 4234, 4235, 3, 995, - 497, 0, 4235, 4236, 3, 985, 492, 0, 4236, 4237, 3, 997, 498, 0, 4237, 4238, - 3, 1003, 501, 0, 4238, 4239, 3, 1019, 509, 0, 4239, 4240, 3, 1011, 505, - 0, 4240, 744, 1, 0, 0, 0, 4241, 4242, 3, 983, 491, 0, 4242, 4243, 3, 1001, - 500, 0, 4243, 4244, 3, 1015, 507, 0, 4244, 4245, 3, 999, 499, 0, 4245, - 4246, 3, 983, 491, 0, 4246, 4247, 3, 1009, 504, 0, 4247, 4248, 3, 975, - 487, 0, 4248, 4249, 3, 1013, 506, 0, 4249, 4250, 3, 991, 495, 0, 4250, - 4251, 3, 1003, 501, 0, 4251, 4252, 3, 1001, 500, 0, 4252, 4253, 3, 1011, - 505, 0, 4253, 746, 1, 0, 0, 0, 4254, 4255, 3, 979, 489, 0, 4255, 4256, - 3, 1003, 501, 0, 4256, 4257, 3, 1001, 500, 0, 4257, 4258, 3, 1011, 505, - 0, 4258, 4259, 3, 1013, 506, 0, 4259, 4260, 3, 975, 487, 0, 4260, 4261, - 3, 1001, 500, 0, 4261, 4262, 3, 1013, 506, 0, 4262, 4263, 3, 1011, 505, - 0, 4263, 748, 1, 0, 0, 0, 4264, 4265, 3, 979, 489, 0, 4265, 4266, 3, 1003, - 501, 0, 4266, 4267, 3, 1001, 500, 0, 4267, 4268, 3, 1001, 500, 0, 4268, - 4269, 3, 983, 491, 0, 4269, 4270, 3, 979, 489, 0, 4270, 4271, 3, 1013, - 506, 0, 4271, 4272, 3, 991, 495, 0, 4272, 4273, 3, 1003, 501, 0, 4273, - 4274, 3, 1001, 500, 0, 4274, 4275, 3, 1011, 505, 0, 4275, 750, 1, 0, 0, - 0, 4276, 4277, 3, 981, 490, 0, 4277, 4278, 3, 983, 491, 0, 4278, 4279, - 3, 985, 492, 0, 4279, 4280, 3, 991, 495, 0, 4280, 4281, 3, 1001, 500, 0, - 4281, 4282, 3, 983, 491, 0, 4282, 752, 1, 0, 0, 0, 4283, 4284, 3, 985, - 492, 0, 4284, 4285, 3, 1009, 504, 0, 4285, 4286, 3, 975, 487, 0, 4286, - 4287, 3, 987, 493, 0, 4287, 4288, 3, 999, 499, 0, 4288, 4289, 3, 983, 491, - 0, 4289, 4290, 3, 1001, 500, 0, 4290, 4291, 3, 1013, 506, 0, 4291, 754, - 1, 0, 0, 0, 4292, 4293, 3, 985, 492, 0, 4293, 4294, 3, 1009, 504, 0, 4294, - 4295, 3, 975, 487, 0, 4295, 4296, 3, 987, 493, 0, 4296, 4297, 3, 999, 499, - 0, 4297, 4298, 3, 983, 491, 0, 4298, 4299, 3, 1001, 500, 0, 4299, 4300, - 3, 1013, 506, 0, 4300, 4301, 3, 1011, 505, 0, 4301, 756, 1, 0, 0, 0, 4302, - 4303, 3, 991, 495, 0, 4303, 4304, 3, 1001, 500, 0, 4304, 4305, 3, 1011, - 505, 0, 4305, 4306, 3, 983, 491, 0, 4306, 4307, 3, 1009, 504, 0, 4307, - 4308, 3, 1013, 506, 0, 4308, 758, 1, 0, 0, 0, 4309, 4310, 3, 977, 488, - 0, 4310, 4311, 3, 983, 491, 0, 4311, 4312, 3, 985, 492, 0, 4312, 4313, - 3, 1003, 501, 0, 4313, 4314, 3, 1009, 504, 0, 4314, 4315, 3, 983, 491, - 0, 4315, 760, 1, 0, 0, 0, 4316, 4317, 3, 975, 487, 0, 4317, 4318, 3, 985, - 492, 0, 4318, 4319, 3, 1013, 506, 0, 4319, 4320, 3, 983, 491, 0, 4320, - 4321, 3, 1009, 504, 0, 4321, 762, 1, 0, 0, 0, 4322, 4323, 3, 1015, 507, - 0, 4323, 4324, 3, 1005, 502, 0, 4324, 4325, 3, 981, 490, 0, 4325, 4326, - 3, 975, 487, 0, 4326, 4327, 3, 1013, 506, 0, 4327, 4328, 3, 983, 491, 0, - 4328, 764, 1, 0, 0, 0, 4329, 4330, 3, 1009, 504, 0, 4330, 4331, 3, 983, - 491, 0, 4331, 4332, 3, 985, 492, 0, 4332, 4333, 3, 1009, 504, 0, 4333, - 4334, 3, 983, 491, 0, 4334, 4335, 3, 1011, 505, 0, 4335, 4336, 3, 989, - 494, 0, 4336, 766, 1, 0, 0, 0, 4337, 4338, 3, 979, 489, 0, 4338, 4339, - 3, 989, 494, 0, 4339, 4340, 3, 983, 491, 0, 4340, 4341, 3, 979, 489, 0, - 4341, 4342, 3, 995, 497, 0, 4342, 768, 1, 0, 0, 0, 4343, 4344, 3, 977, - 488, 0, 4344, 4345, 3, 1015, 507, 0, 4345, 4346, 3, 991, 495, 0, 4346, - 4347, 3, 997, 498, 0, 4347, 4348, 3, 981, 490, 0, 4348, 770, 1, 0, 0, 0, - 4349, 4350, 3, 983, 491, 0, 4350, 4351, 3, 1021, 510, 0, 4351, 4352, 3, - 983, 491, 0, 4352, 4353, 3, 979, 489, 0, 4353, 4354, 3, 1015, 507, 0, 4354, - 4355, 3, 1013, 506, 0, 4355, 4356, 3, 983, 491, 0, 4356, 772, 1, 0, 0, - 0, 4357, 4358, 3, 1011, 505, 0, 4358, 4359, 3, 979, 489, 0, 4359, 4360, - 3, 1009, 504, 0, 4360, 4361, 3, 991, 495, 0, 4361, 4362, 3, 1005, 502, - 0, 4362, 4363, 3, 1013, 506, 0, 4363, 774, 1, 0, 0, 0, 4364, 4365, 3, 997, - 498, 0, 4365, 4366, 3, 991, 495, 0, 4366, 4367, 3, 1001, 500, 0, 4367, - 4368, 3, 1013, 506, 0, 4368, 776, 1, 0, 0, 0, 4369, 4370, 3, 1009, 504, - 0, 4370, 4371, 3, 1015, 507, 0, 4371, 4372, 3, 997, 498, 0, 4372, 4373, - 3, 983, 491, 0, 4373, 4374, 3, 1011, 505, 0, 4374, 778, 1, 0, 0, 0, 4375, - 4376, 3, 1013, 506, 0, 4376, 4377, 3, 983, 491, 0, 4377, 4378, 3, 1021, - 510, 0, 4378, 4379, 3, 1013, 506, 0, 4379, 780, 1, 0, 0, 0, 4380, 4381, - 3, 1011, 505, 0, 4381, 4382, 3, 975, 487, 0, 4382, 4383, 3, 1009, 504, - 0, 4383, 4384, 3, 991, 495, 0, 4384, 4385, 3, 985, 492, 0, 4385, 782, 1, - 0, 0, 0, 4386, 4387, 3, 999, 499, 0, 4387, 4388, 3, 983, 491, 0, 4388, - 4389, 3, 1011, 505, 0, 4389, 4390, 3, 1011, 505, 0, 4390, 4391, 3, 975, - 487, 0, 4391, 4392, 3, 987, 493, 0, 4392, 4393, 3, 983, 491, 0, 4393, 784, - 1, 0, 0, 0, 4394, 4395, 3, 979, 489, 0, 4395, 4396, 3, 1003, 501, 0, 4396, - 4397, 3, 999, 499, 0, 4397, 4398, 3, 999, 499, 0, 4398, 4399, 3, 983, 491, - 0, 4399, 4400, 3, 1001, 500, 0, 4400, 4401, 3, 1013, 506, 0, 4401, 786, - 1, 0, 0, 0, 4402, 4403, 3, 979, 489, 0, 4403, 4404, 3, 975, 487, 0, 4404, - 4405, 3, 1013, 506, 0, 4405, 4406, 3, 975, 487, 0, 4406, 4407, 3, 997, - 498, 0, 4407, 4408, 3, 1003, 501, 0, 4408, 4409, 3, 987, 493, 0, 4409, - 788, 1, 0, 0, 0, 4410, 4411, 3, 985, 492, 0, 4411, 4412, 3, 1003, 501, - 0, 4412, 4413, 3, 1009, 504, 0, 4413, 4414, 3, 979, 489, 0, 4414, 4415, - 3, 983, 491, 0, 4415, 790, 1, 0, 0, 0, 4416, 4417, 3, 977, 488, 0, 4417, - 4418, 3, 975, 487, 0, 4418, 4419, 3, 979, 489, 0, 4419, 4420, 3, 995, 497, - 0, 4420, 4421, 3, 987, 493, 0, 4421, 4422, 3, 1009, 504, 0, 4422, 4423, - 3, 1003, 501, 0, 4423, 4424, 3, 1015, 507, 0, 4424, 4425, 3, 1001, 500, - 0, 4425, 4426, 3, 981, 490, 0, 4426, 792, 1, 0, 0, 0, 4427, 4428, 3, 979, - 489, 0, 4428, 4429, 3, 975, 487, 0, 4429, 4430, 3, 997, 498, 0, 4430, 4431, - 3, 997, 498, 0, 4431, 4432, 3, 983, 491, 0, 4432, 4433, 3, 1009, 504, 0, - 4433, 4434, 3, 1011, 505, 0, 4434, 794, 1, 0, 0, 0, 4435, 4436, 3, 979, - 489, 0, 4436, 4437, 3, 975, 487, 0, 4437, 4438, 3, 997, 498, 0, 4438, 4439, - 3, 997, 498, 0, 4439, 4440, 3, 983, 491, 0, 4440, 4441, 3, 983, 491, 0, - 4441, 4442, 3, 1011, 505, 0, 4442, 796, 1, 0, 0, 0, 4443, 4444, 3, 1009, - 504, 0, 4444, 4445, 3, 983, 491, 0, 4445, 4446, 3, 985, 492, 0, 4446, 4447, - 3, 983, 491, 0, 4447, 4448, 3, 1009, 504, 0, 4448, 4449, 3, 983, 491, 0, - 4449, 4450, 3, 1001, 500, 0, 4450, 4451, 3, 979, 489, 0, 4451, 4452, 3, - 983, 491, 0, 4452, 4453, 3, 1011, 505, 0, 4453, 798, 1, 0, 0, 0, 4454, - 4455, 3, 1013, 506, 0, 4455, 4456, 3, 1009, 504, 0, 4456, 4457, 3, 975, - 487, 0, 4457, 4458, 3, 1001, 500, 0, 4458, 4459, 3, 1011, 505, 0, 4459, - 4460, 3, 991, 495, 0, 4460, 4461, 3, 1013, 506, 0, 4461, 4462, 3, 991, - 495, 0, 4462, 4463, 3, 1017, 508, 0, 4463, 4464, 3, 983, 491, 0, 4464, - 800, 1, 0, 0, 0, 4465, 4466, 3, 991, 495, 0, 4466, 4467, 3, 999, 499, 0, - 4467, 4468, 3, 1005, 502, 0, 4468, 4469, 3, 975, 487, 0, 4469, 4470, 3, - 979, 489, 0, 4470, 4471, 3, 1013, 506, 0, 4471, 802, 1, 0, 0, 0, 4472, - 4473, 3, 981, 490, 0, 4473, 4474, 3, 983, 491, 0, 4474, 4475, 3, 1005, - 502, 0, 4475, 4476, 3, 1013, 506, 0, 4476, 4477, 3, 989, 494, 0, 4477, - 804, 1, 0, 0, 0, 4478, 4479, 3, 1011, 505, 0, 4479, 4480, 3, 1013, 506, - 0, 4480, 4481, 3, 1009, 504, 0, 4481, 4482, 3, 1015, 507, 0, 4482, 4483, - 3, 979, 489, 0, 4483, 4484, 3, 1013, 506, 0, 4484, 4485, 3, 1015, 507, - 0, 4485, 4486, 3, 1009, 504, 0, 4486, 4487, 3, 983, 491, 0, 4487, 806, - 1, 0, 0, 0, 4488, 4489, 3, 1013, 506, 0, 4489, 4490, 3, 1023, 511, 0, 4490, - 4491, 3, 1005, 502, 0, 4491, 4492, 3, 983, 491, 0, 4492, 808, 1, 0, 0, - 0, 4493, 4494, 3, 1017, 508, 0, 4494, 4495, 3, 975, 487, 0, 4495, 4496, - 3, 997, 498, 0, 4496, 4497, 3, 1015, 507, 0, 4497, 4498, 3, 983, 491, 0, - 4498, 810, 1, 0, 0, 0, 4499, 4500, 3, 1011, 505, 0, 4500, 4501, 3, 991, - 495, 0, 4501, 4502, 3, 1001, 500, 0, 4502, 4503, 3, 987, 493, 0, 4503, - 4504, 3, 997, 498, 0, 4504, 4505, 3, 983, 491, 0, 4505, 812, 1, 0, 0, 0, - 4506, 4507, 3, 999, 499, 0, 4507, 4508, 3, 1015, 507, 0, 4508, 4509, 3, - 997, 498, 0, 4509, 4510, 3, 1013, 506, 0, 4510, 4511, 3, 991, 495, 0, 4511, - 4512, 3, 1005, 502, 0, 4512, 4513, 3, 997, 498, 0, 4513, 4514, 3, 983, - 491, 0, 4514, 814, 1, 0, 0, 0, 4515, 4516, 3, 1001, 500, 0, 4516, 4517, - 3, 1003, 501, 0, 4517, 4518, 3, 1001, 500, 0, 4518, 4519, 3, 983, 491, - 0, 4519, 816, 1, 0, 0, 0, 4520, 4521, 3, 977, 488, 0, 4521, 4522, 3, 1003, - 501, 0, 4522, 4523, 3, 1013, 506, 0, 4523, 4524, 3, 989, 494, 0, 4524, - 818, 1, 0, 0, 0, 4525, 4526, 3, 1013, 506, 0, 4526, 4527, 3, 1003, 501, - 0, 4527, 820, 1, 0, 0, 0, 4528, 4529, 3, 1003, 501, 0, 4529, 4530, 3, 985, - 492, 0, 4530, 822, 1, 0, 0, 0, 4531, 4532, 3, 1003, 501, 0, 4532, 4533, - 3, 1017, 508, 0, 4533, 4534, 3, 983, 491, 0, 4534, 4535, 3, 1009, 504, - 0, 4535, 824, 1, 0, 0, 0, 4536, 4537, 3, 985, 492, 0, 4537, 4538, 3, 1003, - 501, 0, 4538, 4539, 3, 1009, 504, 0, 4539, 826, 1, 0, 0, 0, 4540, 4541, - 3, 1009, 504, 0, 4541, 4542, 3, 983, 491, 0, 4542, 4543, 3, 1005, 502, - 0, 4543, 4544, 3, 997, 498, 0, 4544, 4545, 3, 975, 487, 0, 4545, 4546, - 3, 979, 489, 0, 4546, 4547, 3, 983, 491, 0, 4547, 828, 1, 0, 0, 0, 4548, - 4549, 3, 999, 499, 0, 4549, 4550, 3, 983, 491, 0, 4550, 4551, 3, 999, 499, - 0, 4551, 4552, 3, 977, 488, 0, 4552, 4553, 3, 983, 491, 0, 4553, 4554, - 3, 1009, 504, 0, 4554, 4555, 3, 1011, 505, 0, 4555, 830, 1, 0, 0, 0, 4556, - 4557, 3, 975, 487, 0, 4557, 4558, 3, 1013, 506, 0, 4558, 4559, 3, 1013, - 506, 0, 4559, 4560, 3, 1009, 504, 0, 4560, 4561, 3, 991, 495, 0, 4561, - 4562, 3, 977, 488, 0, 4562, 4563, 3, 1015, 507, 0, 4563, 4564, 3, 1013, - 506, 0, 4564, 4565, 3, 983, 491, 0, 4565, 4566, 3, 1001, 500, 0, 4566, - 4567, 3, 975, 487, 0, 4567, 4568, 3, 999, 499, 0, 4568, 4569, 3, 983, 491, - 0, 4569, 832, 1, 0, 0, 0, 4570, 4571, 3, 985, 492, 0, 4571, 4572, 3, 1003, - 501, 0, 4572, 4573, 3, 1009, 504, 0, 4573, 4574, 3, 999, 499, 0, 4574, - 4575, 3, 975, 487, 0, 4575, 4576, 3, 1013, 506, 0, 4576, 834, 1, 0, 0, - 0, 4577, 4578, 3, 1011, 505, 0, 4578, 4579, 3, 1007, 503, 0, 4579, 4580, - 3, 997, 498, 0, 4580, 836, 1, 0, 0, 0, 4581, 4582, 3, 1019, 509, 0, 4582, - 4583, 3, 991, 495, 0, 4583, 4584, 3, 1013, 506, 0, 4584, 4585, 3, 989, - 494, 0, 4585, 4586, 3, 1003, 501, 0, 4586, 4587, 3, 1015, 507, 0, 4587, - 4588, 3, 1013, 506, 0, 4588, 838, 1, 0, 0, 0, 4589, 4590, 3, 981, 490, - 0, 4590, 4591, 3, 1009, 504, 0, 4591, 4592, 3, 1023, 511, 0, 4592, 840, - 1, 0, 0, 0, 4593, 4594, 3, 1009, 504, 0, 4594, 4595, 3, 1015, 507, 0, 4595, - 4596, 3, 1001, 500, 0, 4596, 842, 1, 0, 0, 0, 4597, 4598, 3, 1019, 509, - 0, 4598, 4599, 3, 991, 495, 0, 4599, 4600, 3, 981, 490, 0, 4600, 4601, - 3, 987, 493, 0, 4601, 4602, 3, 983, 491, 0, 4602, 4603, 3, 1013, 506, 0, - 4603, 4604, 3, 1013, 506, 0, 4604, 4605, 3, 1023, 511, 0, 4605, 4606, 3, - 1005, 502, 0, 4606, 4607, 3, 983, 491, 0, 4607, 844, 1, 0, 0, 0, 4608, - 4609, 3, 1017, 508, 0, 4609, 4610, 5, 51, 0, 0, 4610, 846, 1, 0, 0, 0, - 4611, 4612, 3, 977, 488, 0, 4612, 4613, 3, 1015, 507, 0, 4613, 4614, 3, - 1011, 505, 0, 4614, 4615, 3, 991, 495, 0, 4615, 4616, 3, 1001, 500, 0, - 4616, 4617, 3, 983, 491, 0, 4617, 4618, 3, 1011, 505, 0, 4618, 4619, 3, - 1011, 505, 0, 4619, 848, 1, 0, 0, 0, 4620, 4621, 3, 983, 491, 0, 4621, - 4622, 3, 1017, 508, 0, 4622, 4623, 3, 983, 491, 0, 4623, 4624, 3, 1001, - 500, 0, 4624, 4625, 3, 1013, 506, 0, 4625, 850, 1, 0, 0, 0, 4626, 4627, - 3, 1011, 505, 0, 4627, 4628, 3, 1015, 507, 0, 4628, 4629, 3, 977, 488, - 0, 4629, 4630, 3, 1011, 505, 0, 4630, 4631, 3, 979, 489, 0, 4631, 4632, - 3, 1009, 504, 0, 4632, 4633, 3, 991, 495, 0, 4633, 4634, 3, 977, 488, 0, - 4634, 4635, 3, 983, 491, 0, 4635, 852, 1, 0, 0, 0, 4636, 4637, 3, 1011, - 505, 0, 4637, 4638, 3, 983, 491, 0, 4638, 4639, 3, 1013, 506, 0, 4639, - 4640, 3, 1013, 506, 0, 4640, 4641, 3, 991, 495, 0, 4641, 4642, 3, 1001, - 500, 0, 4642, 4643, 3, 987, 493, 0, 4643, 4644, 3, 1011, 505, 0, 4644, - 854, 1, 0, 0, 0, 4645, 4646, 3, 979, 489, 0, 4646, 4647, 3, 1003, 501, - 0, 4647, 4648, 3, 1001, 500, 0, 4648, 4649, 3, 985, 492, 0, 4649, 4650, - 3, 991, 495, 0, 4650, 4651, 3, 987, 493, 0, 4651, 4652, 3, 1015, 507, 0, - 4652, 4653, 3, 1009, 504, 0, 4653, 4654, 3, 975, 487, 0, 4654, 4655, 3, - 1013, 506, 0, 4655, 4656, 3, 991, 495, 0, 4656, 4657, 3, 1003, 501, 0, - 4657, 4658, 3, 1001, 500, 0, 4658, 856, 1, 0, 0, 0, 4659, 4660, 3, 1011, - 505, 0, 4660, 4661, 3, 983, 491, 0, 4661, 4662, 3, 979, 489, 0, 4662, 4663, - 3, 1015, 507, 0, 4663, 4664, 3, 1009, 504, 0, 4664, 4665, 3, 991, 495, - 0, 4665, 4666, 3, 1013, 506, 0, 4666, 4667, 3, 1023, 511, 0, 4667, 858, - 1, 0, 0, 0, 4668, 4669, 3, 1009, 504, 0, 4669, 4670, 3, 1003, 501, 0, 4670, - 4671, 3, 997, 498, 0, 4671, 4672, 3, 983, 491, 0, 4672, 860, 1, 0, 0, 0, - 4673, 4674, 3, 1009, 504, 0, 4674, 4675, 3, 1003, 501, 0, 4675, 4676, 3, - 997, 498, 0, 4676, 4677, 3, 983, 491, 0, 4677, 4678, 3, 1011, 505, 0, 4678, - 862, 1, 0, 0, 0, 4679, 4680, 3, 987, 493, 0, 4680, 4681, 3, 1009, 504, - 0, 4681, 4682, 3, 975, 487, 0, 4682, 4683, 3, 1001, 500, 0, 4683, 4684, - 3, 1013, 506, 0, 4684, 864, 1, 0, 0, 0, 4685, 4686, 3, 1009, 504, 0, 4686, - 4687, 3, 983, 491, 0, 4687, 4688, 3, 1017, 508, 0, 4688, 4689, 3, 1003, - 501, 0, 4689, 4690, 3, 995, 497, 0, 4690, 4691, 3, 983, 491, 0, 4691, 866, - 1, 0, 0, 0, 4692, 4693, 3, 1005, 502, 0, 4693, 4694, 3, 1009, 504, 0, 4694, - 4695, 3, 1003, 501, 0, 4695, 4696, 3, 981, 490, 0, 4696, 4697, 3, 1015, - 507, 0, 4697, 4698, 3, 979, 489, 0, 4698, 4699, 3, 1013, 506, 0, 4699, - 4700, 3, 991, 495, 0, 4700, 4701, 3, 1003, 501, 0, 4701, 4702, 3, 1001, - 500, 0, 4702, 868, 1, 0, 0, 0, 4703, 4704, 3, 1005, 502, 0, 4704, 4705, - 3, 1009, 504, 0, 4705, 4706, 3, 1003, 501, 0, 4706, 4707, 3, 1013, 506, - 0, 4707, 4708, 3, 1003, 501, 0, 4708, 4709, 3, 1013, 506, 0, 4709, 4710, - 3, 1023, 511, 0, 4710, 4711, 3, 1005, 502, 0, 4711, 4712, 3, 983, 491, - 0, 4712, 870, 1, 0, 0, 0, 4713, 4714, 3, 999, 499, 0, 4714, 4715, 3, 975, - 487, 0, 4715, 4716, 3, 1001, 500, 0, 4716, 4717, 3, 975, 487, 0, 4717, - 4718, 3, 987, 493, 0, 4718, 4719, 3, 983, 491, 0, 4719, 872, 1, 0, 0, 0, - 4720, 4721, 3, 981, 490, 0, 4721, 4722, 3, 983, 491, 0, 4722, 4723, 3, - 999, 499, 0, 4723, 4724, 3, 1003, 501, 0, 4724, 874, 1, 0, 0, 0, 4725, - 4726, 3, 999, 499, 0, 4726, 4727, 3, 975, 487, 0, 4727, 4728, 3, 1013, - 506, 0, 4728, 4729, 3, 1009, 504, 0, 4729, 4730, 3, 991, 495, 0, 4730, - 4731, 3, 1021, 510, 0, 4731, 876, 1, 0, 0, 0, 4732, 4733, 3, 975, 487, - 0, 4733, 4734, 3, 1005, 502, 0, 4734, 4735, 3, 1005, 502, 0, 4735, 4736, - 3, 997, 498, 0, 4736, 4737, 3, 1023, 511, 0, 4737, 878, 1, 0, 0, 0, 4738, - 4739, 3, 975, 487, 0, 4739, 4740, 3, 979, 489, 0, 4740, 4741, 3, 979, 489, - 0, 4741, 4742, 3, 983, 491, 0, 4742, 4743, 3, 1011, 505, 0, 4743, 4744, - 3, 1011, 505, 0, 4744, 880, 1, 0, 0, 0, 4745, 4746, 3, 997, 498, 0, 4746, - 4747, 3, 983, 491, 0, 4747, 4748, 3, 1017, 508, 0, 4748, 4749, 3, 983, - 491, 0, 4749, 4750, 3, 997, 498, 0, 4750, 882, 1, 0, 0, 0, 4751, 4752, - 3, 1015, 507, 0, 4752, 4753, 3, 1011, 505, 0, 4753, 4754, 3, 983, 491, - 0, 4754, 4755, 3, 1009, 504, 0, 4755, 884, 1, 0, 0, 0, 4756, 4757, 3, 1009, - 504, 0, 4757, 4758, 3, 983, 491, 0, 4758, 4759, 3, 975, 487, 0, 4759, 4760, - 3, 981, 490, 0, 4760, 886, 1, 0, 0, 0, 4761, 4762, 3, 1019, 509, 0, 4762, - 4763, 3, 1009, 504, 0, 4763, 4764, 3, 991, 495, 0, 4764, 4765, 3, 1013, - 506, 0, 4765, 4766, 3, 983, 491, 0, 4766, 888, 1, 0, 0, 0, 4767, 4768, - 3, 981, 490, 0, 4768, 4769, 3, 983, 491, 0, 4769, 4770, 3, 1011, 505, 0, - 4770, 4771, 3, 979, 489, 0, 4771, 4772, 3, 1009, 504, 0, 4772, 4773, 3, - 991, 495, 0, 4773, 4774, 3, 1005, 502, 0, 4774, 4775, 3, 1013, 506, 0, - 4775, 4776, 3, 991, 495, 0, 4776, 4777, 3, 1003, 501, 0, 4777, 4778, 3, - 1001, 500, 0, 4778, 890, 1, 0, 0, 0, 4779, 4780, 3, 1003, 501, 0, 4780, - 4781, 3, 985, 492, 0, 4781, 4782, 3, 985, 492, 0, 4782, 892, 1, 0, 0, 0, - 4783, 4784, 3, 1015, 507, 0, 4784, 4785, 3, 1011, 505, 0, 4785, 4786, 3, - 983, 491, 0, 4786, 4787, 3, 1009, 504, 0, 4787, 4788, 3, 1011, 505, 0, - 4788, 894, 1, 0, 0, 0, 4789, 4790, 5, 60, 0, 0, 4790, 4794, 5, 62, 0, 0, - 4791, 4792, 5, 33, 0, 0, 4792, 4794, 5, 61, 0, 0, 4793, 4789, 1, 0, 0, - 0, 4793, 4791, 1, 0, 0, 0, 4794, 896, 1, 0, 0, 0, 4795, 4796, 5, 60, 0, - 0, 4796, 4797, 5, 61, 0, 0, 4797, 898, 1, 0, 0, 0, 4798, 4799, 5, 62, 0, - 0, 4799, 4800, 5, 61, 0, 0, 4800, 900, 1, 0, 0, 0, 4801, 4802, 5, 61, 0, - 0, 4802, 902, 1, 0, 0, 0, 4803, 4804, 5, 60, 0, 0, 4804, 904, 1, 0, 0, - 0, 4805, 4806, 5, 62, 0, 0, 4806, 906, 1, 0, 0, 0, 4807, 4808, 5, 43, 0, - 0, 4808, 908, 1, 0, 0, 0, 4809, 4810, 5, 45, 0, 0, 4810, 910, 1, 0, 0, - 0, 4811, 4812, 5, 42, 0, 0, 4812, 912, 1, 0, 0, 0, 4813, 4814, 5, 47, 0, - 0, 4814, 914, 1, 0, 0, 0, 4815, 4816, 5, 37, 0, 0, 4816, 916, 1, 0, 0, - 0, 4817, 4818, 3, 999, 499, 0, 4818, 4819, 3, 1003, 501, 0, 4819, 4820, - 3, 981, 490, 0, 4820, 918, 1, 0, 0, 0, 4821, 4822, 3, 981, 490, 0, 4822, - 4823, 3, 991, 495, 0, 4823, 4824, 3, 1017, 508, 0, 4824, 920, 1, 0, 0, - 0, 4825, 4826, 5, 59, 0, 0, 4826, 922, 1, 0, 0, 0, 4827, 4828, 5, 44, 0, - 0, 4828, 924, 1, 0, 0, 0, 4829, 4830, 5, 46, 0, 0, 4830, 926, 1, 0, 0, - 0, 4831, 4832, 5, 40, 0, 0, 4832, 928, 1, 0, 0, 0, 4833, 4834, 5, 41, 0, - 0, 4834, 930, 1, 0, 0, 0, 4835, 4836, 5, 123, 0, 0, 4836, 932, 1, 0, 0, - 0, 4837, 4838, 5, 125, 0, 0, 4838, 934, 1, 0, 0, 0, 4839, 4840, 5, 91, - 0, 0, 4840, 936, 1, 0, 0, 0, 4841, 4842, 5, 93, 0, 0, 4842, 938, 1, 0, - 0, 0, 4843, 4844, 5, 58, 0, 0, 4844, 940, 1, 0, 0, 0, 4845, 4846, 5, 64, - 0, 0, 4846, 942, 1, 0, 0, 0, 4847, 4848, 5, 124, 0, 0, 4848, 944, 1, 0, - 0, 0, 4849, 4850, 5, 58, 0, 0, 4850, 4851, 5, 58, 0, 0, 4851, 946, 1, 0, - 0, 0, 4852, 4853, 5, 45, 0, 0, 4853, 4854, 5, 62, 0, 0, 4854, 948, 1, 0, - 0, 0, 4855, 4856, 5, 63, 0, 0, 4856, 950, 1, 0, 0, 0, 4857, 4858, 5, 35, - 0, 0, 4858, 952, 1, 0, 0, 0, 4859, 4860, 5, 91, 0, 0, 4860, 4861, 5, 37, - 0, 0, 4861, 4865, 1, 0, 0, 0, 4862, 4864, 9, 0, 0, 0, 4863, 4862, 1, 0, - 0, 0, 4864, 4867, 1, 0, 0, 0, 4865, 4866, 1, 0, 0, 0, 4865, 4863, 1, 0, - 0, 0, 4866, 4868, 1, 0, 0, 0, 4867, 4865, 1, 0, 0, 0, 4868, 4869, 5, 37, - 0, 0, 4869, 4870, 5, 93, 0, 0, 4870, 954, 1, 0, 0, 0, 4871, 4879, 5, 39, - 0, 0, 4872, 4878, 8, 2, 0, 0, 4873, 4874, 5, 92, 0, 0, 4874, 4878, 9, 0, - 0, 0, 4875, 4876, 5, 39, 0, 0, 4876, 4878, 5, 39, 0, 0, 4877, 4872, 1, - 0, 0, 0, 4877, 4873, 1, 0, 0, 0, 4877, 4875, 1, 0, 0, 0, 4878, 4881, 1, - 0, 0, 0, 4879, 4877, 1, 0, 0, 0, 4879, 4880, 1, 0, 0, 0, 4880, 4882, 1, - 0, 0, 0, 4881, 4879, 1, 0, 0, 0, 4882, 4883, 5, 39, 0, 0, 4883, 956, 1, - 0, 0, 0, 4884, 4885, 5, 36, 0, 0, 4885, 4886, 5, 36, 0, 0, 4886, 4890, - 1, 0, 0, 0, 4887, 4889, 9, 0, 0, 0, 4888, 4887, 1, 0, 0, 0, 4889, 4892, - 1, 0, 0, 0, 4890, 4891, 1, 0, 0, 0, 4890, 4888, 1, 0, 0, 0, 4891, 4893, - 1, 0, 0, 0, 4892, 4890, 1, 0, 0, 0, 4893, 4894, 5, 36, 0, 0, 4894, 4895, - 5, 36, 0, 0, 4895, 958, 1, 0, 0, 0, 4896, 4898, 5, 45, 0, 0, 4897, 4896, - 1, 0, 0, 0, 4897, 4898, 1, 0, 0, 0, 4898, 4900, 1, 0, 0, 0, 4899, 4901, - 3, 973, 486, 0, 4900, 4899, 1, 0, 0, 0, 4901, 4902, 1, 0, 0, 0, 4902, 4900, - 1, 0, 0, 0, 4902, 4903, 1, 0, 0, 0, 4903, 4910, 1, 0, 0, 0, 4904, 4906, - 5, 46, 0, 0, 4905, 4907, 3, 973, 486, 0, 4906, 4905, 1, 0, 0, 0, 4907, - 4908, 1, 0, 0, 0, 4908, 4906, 1, 0, 0, 0, 4908, 4909, 1, 0, 0, 0, 4909, - 4911, 1, 0, 0, 0, 4910, 4904, 1, 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, - 4921, 1, 0, 0, 0, 4912, 4914, 7, 3, 0, 0, 4913, 4915, 7, 4, 0, 0, 4914, - 4913, 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 4917, 1, 0, 0, 0, 4916, - 4918, 3, 973, 486, 0, 4917, 4916, 1, 0, 0, 0, 4918, 4919, 1, 0, 0, 0, 4919, - 4917, 1, 0, 0, 0, 4919, 4920, 1, 0, 0, 0, 4920, 4922, 1, 0, 0, 0, 4921, - 4912, 1, 0, 0, 0, 4921, 4922, 1, 0, 0, 0, 4922, 960, 1, 0, 0, 0, 4923, - 4925, 5, 36, 0, 0, 4924, 4926, 3, 971, 485, 0, 4925, 4924, 1, 0, 0, 0, - 4926, 4927, 1, 0, 0, 0, 4927, 4925, 1, 0, 0, 0, 4927, 4928, 1, 0, 0, 0, - 4928, 962, 1, 0, 0, 0, 4929, 4933, 3, 969, 484, 0, 4930, 4932, 3, 971, - 485, 0, 4931, 4930, 1, 0, 0, 0, 4932, 4935, 1, 0, 0, 0, 4933, 4931, 1, - 0, 0, 0, 4933, 4934, 1, 0, 0, 0, 4934, 964, 1, 0, 0, 0, 4935, 4933, 1, - 0, 0, 0, 4936, 4944, 3, 969, 484, 0, 4937, 4939, 3, 971, 485, 0, 4938, - 4937, 1, 0, 0, 0, 4939, 4942, 1, 0, 0, 0, 4940, 4938, 1, 0, 0, 0, 4940, - 4941, 1, 0, 0, 0, 4941, 4943, 1, 0, 0, 0, 4942, 4940, 1, 0, 0, 0, 4943, - 4945, 5, 45, 0, 0, 4944, 4940, 1, 0, 0, 0, 4945, 4946, 1, 0, 0, 0, 4946, - 4944, 1, 0, 0, 0, 4946, 4947, 1, 0, 0, 0, 4947, 4951, 1, 0, 0, 0, 4948, - 4950, 3, 971, 485, 0, 4949, 4948, 1, 0, 0, 0, 4950, 4953, 1, 0, 0, 0, 4951, - 4949, 1, 0, 0, 0, 4951, 4952, 1, 0, 0, 0, 4952, 966, 1, 0, 0, 0, 4953, - 4951, 1, 0, 0, 0, 4954, 4958, 5, 34, 0, 0, 4955, 4957, 8, 5, 0, 0, 4956, - 4955, 1, 0, 0, 0, 4957, 4960, 1, 0, 0, 0, 4958, 4956, 1, 0, 0, 0, 4958, - 4959, 1, 0, 0, 0, 4959, 4961, 1, 0, 0, 0, 4960, 4958, 1, 0, 0, 0, 4961, - 4971, 5, 34, 0, 0, 4962, 4966, 5, 96, 0, 0, 4963, 4965, 8, 6, 0, 0, 4964, - 4963, 1, 0, 0, 0, 4965, 4968, 1, 0, 0, 0, 4966, 4964, 1, 0, 0, 0, 4966, - 4967, 1, 0, 0, 0, 4967, 4969, 1, 0, 0, 0, 4968, 4966, 1, 0, 0, 0, 4969, - 4971, 5, 96, 0, 0, 4970, 4954, 1, 0, 0, 0, 4970, 4962, 1, 0, 0, 0, 4971, - 968, 1, 0, 0, 0, 4972, 4973, 7, 7, 0, 0, 4973, 970, 1, 0, 0, 0, 4974, 4975, - 7, 8, 0, 0, 4975, 972, 1, 0, 0, 0, 4976, 4977, 7, 9, 0, 0, 4977, 974, 1, - 0, 0, 0, 4978, 4979, 7, 10, 0, 0, 4979, 976, 1, 0, 0, 0, 4980, 4981, 7, - 11, 0, 0, 4981, 978, 1, 0, 0, 0, 4982, 4983, 7, 12, 0, 0, 4983, 980, 1, - 0, 0, 0, 4984, 4985, 7, 13, 0, 0, 4985, 982, 1, 0, 0, 0, 4986, 4987, 7, - 3, 0, 0, 4987, 984, 1, 0, 0, 0, 4988, 4989, 7, 14, 0, 0, 4989, 986, 1, - 0, 0, 0, 4990, 4991, 7, 15, 0, 0, 4991, 988, 1, 0, 0, 0, 4992, 4993, 7, - 16, 0, 0, 4993, 990, 1, 0, 0, 0, 4994, 4995, 7, 17, 0, 0, 4995, 992, 1, - 0, 0, 0, 4996, 4997, 7, 18, 0, 0, 4997, 994, 1, 0, 0, 0, 4998, 4999, 7, - 19, 0, 0, 4999, 996, 1, 0, 0, 0, 5000, 5001, 7, 20, 0, 0, 5001, 998, 1, - 0, 0, 0, 5002, 5003, 7, 21, 0, 0, 5003, 1000, 1, 0, 0, 0, 5004, 5005, 7, - 22, 0, 0, 5005, 1002, 1, 0, 0, 0, 5006, 5007, 7, 23, 0, 0, 5007, 1004, - 1, 0, 0, 0, 5008, 5009, 7, 24, 0, 0, 5009, 1006, 1, 0, 0, 0, 5010, 5011, - 7, 25, 0, 0, 5011, 1008, 1, 0, 0, 0, 5012, 5013, 7, 26, 0, 0, 5013, 1010, - 1, 0, 0, 0, 5014, 5015, 7, 27, 0, 0, 5015, 1012, 1, 0, 0, 0, 5016, 5017, - 7, 28, 0, 0, 5017, 1014, 1, 0, 0, 0, 5018, 5019, 7, 29, 0, 0, 5019, 1016, - 1, 0, 0, 0, 5020, 5021, 7, 30, 0, 0, 5021, 1018, 1, 0, 0, 0, 5022, 5023, - 7, 31, 0, 0, 5023, 1020, 1, 0, 0, 0, 5024, 5025, 7, 32, 0, 0, 5025, 1022, - 1, 0, 0, 0, 5026, 5027, 7, 33, 0, 0, 5027, 1024, 1, 0, 0, 0, 5028, 5029, - 7, 34, 0, 0, 5029, 1026, 1, 0, 0, 0, 46, 0, 1030, 1041, 1053, 1067, 1077, - 1085, 1097, 1110, 1125, 1138, 1150, 1180, 1193, 1207, 1215, 1270, 1281, - 1289, 1298, 1362, 1373, 1380, 1387, 1445, 1735, 4793, 4865, 4877, 4879, - 4890, 4897, 4902, 4908, 4910, 4914, 4919, 4921, 4927, 4933, 4940, 4946, - 4951, 4958, 4966, 4970, 1, 6, 0, 0, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 3, 15, 1488, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, + 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, + 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, + 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, + 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, + 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, + 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, + 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, + 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, + 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, + 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, + 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, + 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, + 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, + 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, + 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, + 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, + 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, + 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, + 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1778, 8, + 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, + 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, + 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, + 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 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, 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, 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, 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, 66, 1, 66, 1, 66, 1, 66, + 1, 66, 1, 66, 1, 66, 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, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, + 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, 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, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, + 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, + 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, + 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 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, 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, + 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, 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, 90, 1, 91, 1, 91, 1, 91, + 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, + 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, + 1, 95, 1, 95, 1, 96, 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, 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, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, + 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, + 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, + 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, + 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, + 106, 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, 110, 1, 110, 1, 110, 1, 110, 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, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, + 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, + 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, + 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, + 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 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, 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, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, + 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, + 128, 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, 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, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, + 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, + 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, + 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, + 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, + 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, + 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, + 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, + 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, + 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, + 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, + 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, + 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, + 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, + 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, + 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, + 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, + 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 1, + 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, + 157, 1, 157, 1, 157, 1, 157, 1, 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, + 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 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, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, + 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, + 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, + 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 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, + 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, + 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, + 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, + 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, + 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, + 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, + 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, + 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, + 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, + 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, + 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, + 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, + 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, + 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, + 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, + 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, + 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, + 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, + 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, + 185, 1, 185, 1, 185, 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, + 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, + 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, + 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, + 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, + 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, + 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, + 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, + 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, + 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, + 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, + 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, + 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, + 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, + 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, + 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, + 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, + 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, + 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, + 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 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, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, + 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, + 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, + 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, + 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, + 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, + 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, + 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, + 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, + 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, + 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, + 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, + 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, + 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, + 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, + 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, + 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, + 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, + 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, + 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, + 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, + 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, + 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, + 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, + 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, + 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, + 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, + 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, + 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, + 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, + 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, + 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, + 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, + 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, + 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, + 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, + 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, + 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, + 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, + 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, + 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, + 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, + 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, + 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, + 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, + 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, + 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, + 269, 1, 269, 1, 269, 1, 270, 1, 270, 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, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, + 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, + 279, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, + 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, + 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, + 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, + 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, + 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, + 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, + 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, + 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, + 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, + 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, + 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, + 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, + 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, + 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, + 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, + 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, + 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, + 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, + 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, + 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, + 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, + 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, + 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, + 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, + 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, + 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, + 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, + 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, + 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, + 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, + 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, + 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, + 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, + 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, + 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, + 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, + 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, + 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, + 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, + 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, + 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, + 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, + 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, + 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, + 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, + 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, + 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, + 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, + 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, + 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, + 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, + 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, + 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, + 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, + 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, + 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, + 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, + 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, + 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, + 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, + 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, + 362, 1, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, + 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, + 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, + 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, + 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, + 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, + 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, + 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, + 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, + 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, + 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, + 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, + 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, + 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, + 377, 1, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, + 378, 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, + 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, + 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, + 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, + 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, + 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, 1, + 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, + 387, 1, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, + 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, + 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, + 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, + 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, + 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, + 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, + 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, + 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, + 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, + 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, + 400, 1, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, + 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 403, 1, + 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, + 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, + 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, + 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, + 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 409, 1, + 409, 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, + 412, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, + 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, + 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, + 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, + 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, + 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, + 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, + 421, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, + 422, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, 1, + 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, + 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, + 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, + 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, + 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, + 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, + 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 1, 431, 1, + 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, + 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, + 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, + 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, + 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, + 437, 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, + 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, + 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, + 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, + 443, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, + 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, + 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, + 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, + 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, + 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, 449, 1, + 449, 1, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 451, 1, 451, 1, + 451, 1, 451, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, + 452, 1, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, + 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 455, 1, 455, 1, + 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, + 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, + 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, + 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, + 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, + 460, 1, 461, 1, 461, 1, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, + 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, + 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, + 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 1, + 466, 1, 466, 1, 466, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, + 468, 1, 468, 1, 468, 1, 468, 3, 468, 4996, 8, 468, 1, 469, 1, 469, 1, 469, + 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, 472, 1, 472, 1, 473, 1, 473, + 1, 474, 1, 474, 1, 475, 1, 475, 1, 476, 1, 476, 1, 477, 1, 477, 1, 478, + 1, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 480, 1, 480, 1, 480, 1, 480, + 1, 481, 1, 481, 1, 482, 1, 482, 1, 483, 1, 483, 1, 484, 1, 484, 1, 485, + 1, 485, 1, 486, 1, 486, 1, 487, 1, 487, 1, 488, 1, 488, 1, 489, 1, 489, + 1, 490, 1, 490, 1, 491, 1, 491, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, + 1, 494, 1, 494, 1, 494, 1, 495, 1, 495, 1, 496, 1, 496, 1, 497, 1, 497, + 1, 497, 1, 497, 5, 497, 5066, 8, 497, 10, 497, 12, 497, 5069, 9, 497, 1, + 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 5, + 498, 5080, 8, 498, 10, 498, 12, 498, 5083, 9, 498, 1, 498, 1, 498, 1, 499, + 1, 499, 1, 499, 1, 499, 5, 499, 5091, 8, 499, 10, 499, 12, 499, 5094, 9, + 499, 1, 499, 1, 499, 1, 499, 1, 500, 3, 500, 5100, 8, 500, 1, 500, 4, 500, + 5103, 8, 500, 11, 500, 12, 500, 5104, 1, 500, 1, 500, 4, 500, 5109, 8, + 500, 11, 500, 12, 500, 5110, 3, 500, 5113, 8, 500, 1, 500, 1, 500, 3, 500, + 5117, 8, 500, 1, 500, 4, 500, 5120, 8, 500, 11, 500, 12, 500, 5121, 3, + 500, 5124, 8, 500, 1, 501, 1, 501, 4, 501, 5128, 8, 501, 11, 501, 12, 501, + 5129, 1, 502, 1, 502, 5, 502, 5134, 8, 502, 10, 502, 12, 502, 5137, 9, + 502, 1, 503, 1, 503, 5, 503, 5141, 8, 503, 10, 503, 12, 503, 5144, 9, 503, + 1, 503, 4, 503, 5147, 8, 503, 11, 503, 12, 503, 5148, 1, 503, 5, 503, 5152, + 8, 503, 10, 503, 12, 503, 5155, 9, 503, 1, 504, 1, 504, 5, 504, 5159, 8, + 504, 10, 504, 12, 504, 5162, 9, 504, 1, 504, 1, 504, 1, 504, 5, 504, 5167, + 8, 504, 10, 504, 12, 504, 5170, 9, 504, 1, 504, 3, 504, 5173, 8, 504, 1, + 505, 1, 505, 1, 506, 1, 506, 1, 507, 1, 507, 1, 508, 1, 508, 1, 509, 1, + 509, 1, 510, 1, 510, 1, 511, 1, 511, 1, 512, 1, 512, 1, 513, 1, 513, 1, + 514, 1, 514, 1, 515, 1, 515, 1, 516, 1, 516, 1, 517, 1, 517, 1, 518, 1, + 518, 1, 519, 1, 519, 1, 520, 1, 520, 1, 521, 1, 521, 1, 522, 1, 522, 1, + 523, 1, 523, 1, 524, 1, 524, 1, 525, 1, 525, 1, 526, 1, 526, 1, 527, 1, + 527, 1, 528, 1, 528, 1, 529, 1, 529, 1, 530, 1, 530, 1, 531, 1, 531, 1, + 532, 1, 532, 1, 533, 1, 533, 4, 1083, 1095, 5067, 5092, 0, 534, 1, 1, 3, + 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, + 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, + 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, + 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, + 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, + 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, + 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, + 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, + 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, + 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, + 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, + 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, + 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, + 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, + 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, + 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, + 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, + 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, + 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, + 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, + 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, + 172, 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, + 359, 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, + 187, 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, + 389, 195, 391, 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, + 202, 405, 203, 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, + 419, 210, 421, 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, + 217, 435, 218, 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, + 449, 225, 451, 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, + 232, 465, 233, 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, + 479, 240, 481, 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, + 247, 495, 248, 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, + 509, 255, 511, 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, + 262, 525, 263, 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, + 539, 270, 541, 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, + 277, 555, 278, 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, + 569, 285, 571, 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, + 292, 585, 293, 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, + 599, 300, 601, 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, + 307, 615, 308, 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, + 629, 315, 631, 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, + 322, 645, 323, 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, + 659, 330, 661, 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, + 337, 675, 338, 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, + 689, 345, 691, 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, + 352, 705, 353, 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, + 719, 360, 721, 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, + 367, 735, 368, 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, + 749, 375, 751, 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, + 382, 765, 383, 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, + 779, 390, 781, 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, + 397, 795, 398, 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, + 809, 405, 811, 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, + 412, 825, 413, 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, + 839, 420, 841, 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, + 427, 855, 428, 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, + 869, 435, 871, 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, + 442, 885, 443, 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, + 899, 450, 901, 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, + 457, 915, 458, 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, + 929, 465, 931, 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, + 472, 945, 473, 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, + 959, 480, 961, 481, 963, 482, 965, 483, 967, 484, 969, 485, 971, 486, 973, + 487, 975, 488, 977, 489, 979, 490, 981, 491, 983, 492, 985, 493, 987, 494, + 989, 495, 991, 496, 993, 497, 995, 498, 997, 499, 999, 500, 1001, 501, + 1003, 502, 1005, 503, 1007, 504, 1009, 505, 1011, 0, 1013, 0, 1015, 0, + 1017, 0, 1019, 0, 1021, 0, 1023, 0, 1025, 0, 1027, 0, 1029, 0, 1031, 0, + 1033, 0, 1035, 0, 1037, 0, 1039, 0, 1041, 0, 1043, 0, 1045, 0, 1047, 0, + 1049, 0, 1051, 0, 1053, 0, 1055, 0, 1057, 0, 1059, 0, 1061, 0, 1063, 0, + 1065, 0, 1067, 0, 1, 0, 35, 2, 0, 9, 13, 32, 32, 2, 0, 10, 10, 13, 13, + 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 2, 0, 69, 69, 101, 101, 2, 0, 43, + 43, 45, 45, 3, 0, 10, 10, 13, 13, 34, 34, 3, 0, 10, 10, 13, 13, 96, 96, + 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1, + 0, 48, 57, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, + 99, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, + 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, + 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, + 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, + 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, + 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, + 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, + 121, 2, 0, 90, 90, 122, 122, 5251, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, + 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, + 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, + 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, + 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, + 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, + 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, + 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, + 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, + 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, + 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, + 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, + 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, + 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, + 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, + 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, + 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, + 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, + 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, + 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, + 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, + 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, + 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, + 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, + 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, + 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, + 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, + 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, + 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, + 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, + 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, + 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, + 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, + 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, + 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, + 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, + 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, + 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, + 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, + 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, + 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, + 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, + 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, + 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, + 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, + 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, + 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, + 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, + 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, + 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, + 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, + 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, + 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, + 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, + 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, + 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, + 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, + 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, + 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, + 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, + 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, + 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, + 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, + 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, + 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, + 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, + 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, + 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, + 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, + 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, + 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, + 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, + 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, + 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, + 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, + 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, + 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, + 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, + 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, + 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, + 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, + 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, + 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, + 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, + 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, + 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, + 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, + 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, + 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, + 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, + 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, + 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, + 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, + 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, + 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, + 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, + 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, + 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, + 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, + 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, + 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, + 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, + 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, + 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, + 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, + 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, + 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, + 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, + 781, 1, 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, + 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, + 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, + 0, 803, 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, 1, + 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, 813, 1, 0, 0, 0, 0, 815, 1, 0, 0, 0, 0, + 817, 1, 0, 0, 0, 0, 819, 1, 0, 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, 0, + 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, 1, 0, 0, 0, 0, 829, 1, 0, 0, 0, 0, 831, + 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, 0, 835, 1, 0, 0, 0, 0, 837, 1, 0, 0, 0, + 0, 839, 1, 0, 0, 0, 0, 841, 1, 0, 0, 0, 0, 843, 1, 0, 0, 0, 0, 845, 1, + 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, 849, 1, 0, 0, 0, 0, 851, 1, 0, 0, 0, 0, + 853, 1, 0, 0, 0, 0, 855, 1, 0, 0, 0, 0, 857, 1, 0, 0, 0, 0, 859, 1, 0, + 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, 1, 0, 0, 0, 0, 865, 1, 0, 0, 0, 0, 867, + 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, 0, 871, 1, 0, 0, 0, 0, 873, 1, 0, 0, 0, + 0, 875, 1, 0, 0, 0, 0, 877, 1, 0, 0, 0, 0, 879, 1, 0, 0, 0, 0, 881, 1, + 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, 885, 1, 0, 0, 0, 0, 887, 1, 0, 0, 0, 0, + 889, 1, 0, 0, 0, 0, 891, 1, 0, 0, 0, 0, 893, 1, 0, 0, 0, 0, 895, 1, 0, + 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, 1, 0, 0, 0, 0, 901, 1, 0, 0, 0, 0, 903, + 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, 0, 907, 1, 0, 0, 0, 0, 909, 1, 0, 0, 0, + 0, 911, 1, 0, 0, 0, 0, 913, 1, 0, 0, 0, 0, 915, 1, 0, 0, 0, 0, 917, 1, + 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, 921, 1, 0, 0, 0, 0, 923, 1, 0, 0, 0, 0, + 925, 1, 0, 0, 0, 0, 927, 1, 0, 0, 0, 0, 929, 1, 0, 0, 0, 0, 931, 1, 0, + 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, 1, 0, 0, 0, 0, 937, 1, 0, 0, 0, 0, 939, + 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, 0, 943, 1, 0, 0, 0, 0, 945, 1, 0, 0, 0, + 0, 947, 1, 0, 0, 0, 0, 949, 1, 0, 0, 0, 0, 951, 1, 0, 0, 0, 0, 953, 1, + 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, 957, 1, 0, 0, 0, 0, 959, 1, 0, 0, 0, 0, + 961, 1, 0, 0, 0, 0, 963, 1, 0, 0, 0, 0, 965, 1, 0, 0, 0, 0, 967, 1, 0, + 0, 0, 0, 969, 1, 0, 0, 0, 0, 971, 1, 0, 0, 0, 0, 973, 1, 0, 0, 0, 0, 975, + 1, 0, 0, 0, 0, 977, 1, 0, 0, 0, 0, 979, 1, 0, 0, 0, 0, 981, 1, 0, 0, 0, + 0, 983, 1, 0, 0, 0, 0, 985, 1, 0, 0, 0, 0, 987, 1, 0, 0, 0, 0, 989, 1, + 0, 0, 0, 0, 991, 1, 0, 0, 0, 0, 993, 1, 0, 0, 0, 0, 995, 1, 0, 0, 0, 0, + 997, 1, 0, 0, 0, 0, 999, 1, 0, 0, 0, 0, 1001, 1, 0, 0, 0, 0, 1003, 1, 0, + 0, 0, 0, 1005, 1, 0, 0, 0, 0, 1007, 1, 0, 0, 0, 0, 1009, 1, 0, 0, 0, 1, + 1070, 1, 0, 0, 0, 3, 1076, 1, 0, 0, 0, 5, 1089, 1, 0, 0, 0, 7, 1103, 1, + 0, 0, 0, 9, 1114, 1, 0, 0, 0, 11, 1134, 1, 0, 0, 0, 13, 1146, 1, 0, 0, + 0, 15, 1159, 1, 0, 0, 0, 17, 1172, 1, 0, 0, 0, 19, 1185, 1, 0, 0, 0, 21, + 1197, 1, 0, 0, 0, 23, 1212, 1, 0, 0, 0, 25, 1228, 1, 0, 0, 0, 27, 1312, + 1, 0, 0, 0, 29, 1404, 1, 0, 0, 0, 31, 1487, 1, 0, 0, 0, 33, 1489, 1, 0, + 0, 0, 35, 1496, 1, 0, 0, 0, 37, 1502, 1, 0, 0, 0, 39, 1507, 1, 0, 0, 0, + 41, 1514, 1, 0, 0, 0, 43, 1519, 1, 0, 0, 0, 45, 1526, 1, 0, 0, 0, 47, 1533, + 1, 0, 0, 0, 49, 1544, 1, 0, 0, 0, 51, 1549, 1, 0, 0, 0, 53, 1558, 1, 0, + 0, 0, 55, 1570, 1, 0, 0, 0, 57, 1582, 1, 0, 0, 0, 59, 1589, 1, 0, 0, 0, + 61, 1599, 1, 0, 0, 0, 63, 1608, 1, 0, 0, 0, 65, 1617, 1, 0, 0, 0, 67, 1622, + 1, 0, 0, 0, 69, 1630, 1, 0, 0, 0, 71, 1637, 1, 0, 0, 0, 73, 1646, 1, 0, + 0, 0, 75, 1655, 1, 0, 0, 0, 77, 1665, 1, 0, 0, 0, 79, 1672, 1, 0, 0, 0, + 81, 1680, 1, 0, 0, 0, 83, 1686, 1, 0, 0, 0, 85, 1692, 1, 0, 0, 0, 87, 1702, + 1, 0, 0, 0, 89, 1717, 1, 0, 0, 0, 91, 1725, 1, 0, 0, 0, 93, 1729, 1, 0, + 0, 0, 95, 1733, 1, 0, 0, 0, 97, 1742, 1, 0, 0, 0, 99, 1756, 1, 0, 0, 0, + 101, 1764, 1, 0, 0, 0, 103, 1770, 1, 0, 0, 0, 105, 1788, 1, 0, 0, 0, 107, + 1796, 1, 0, 0, 0, 109, 1804, 1, 0, 0, 0, 111, 1812, 1, 0, 0, 0, 113, 1823, + 1, 0, 0, 0, 115, 1829, 1, 0, 0, 0, 117, 1837, 1, 0, 0, 0, 119, 1845, 1, + 0, 0, 0, 121, 1852, 1, 0, 0, 0, 123, 1858, 1, 0, 0, 0, 125, 1863, 1, 0, + 0, 0, 127, 1868, 1, 0, 0, 0, 129, 1873, 1, 0, 0, 0, 131, 1882, 1, 0, 0, + 0, 133, 1886, 1, 0, 0, 0, 135, 1897, 1, 0, 0, 0, 137, 1903, 1, 0, 0, 0, + 139, 1910, 1, 0, 0, 0, 141, 1915, 1, 0, 0, 0, 143, 1921, 1, 0, 0, 0, 145, + 1928, 1, 0, 0, 0, 147, 1935, 1, 0, 0, 0, 149, 1941, 1, 0, 0, 0, 151, 1944, + 1, 0, 0, 0, 153, 1952, 1, 0, 0, 0, 155, 1962, 1, 0, 0, 0, 157, 1967, 1, + 0, 0, 0, 159, 1972, 1, 0, 0, 0, 161, 1977, 1, 0, 0, 0, 163, 1982, 1, 0, + 0, 0, 165, 1986, 1, 0, 0, 0, 167, 1995, 1, 0, 0, 0, 169, 1999, 1, 0, 0, + 0, 171, 2004, 1, 0, 0, 0, 173, 2009, 1, 0, 0, 0, 175, 2015, 1, 0, 0, 0, + 177, 2021, 1, 0, 0, 0, 179, 2027, 1, 0, 0, 0, 181, 2032, 1, 0, 0, 0, 183, + 2038, 1, 0, 0, 0, 185, 2041, 1, 0, 0, 0, 187, 2045, 1, 0, 0, 0, 189, 2050, + 1, 0, 0, 0, 191, 2056, 1, 0, 0, 0, 193, 2064, 1, 0, 0, 0, 195, 2071, 1, + 0, 0, 0, 197, 2080, 1, 0, 0, 0, 199, 2087, 1, 0, 0, 0, 201, 2094, 1, 0, + 0, 0, 203, 2103, 1, 0, 0, 0, 205, 2108, 1, 0, 0, 0, 207, 2114, 1, 0, 0, + 0, 209, 2117, 1, 0, 0, 0, 211, 2123, 1, 0, 0, 0, 213, 2130, 1, 0, 0, 0, + 215, 2139, 1, 0, 0, 0, 217, 2145, 1, 0, 0, 0, 219, 2152, 1, 0, 0, 0, 221, + 2158, 1, 0, 0, 0, 223, 2162, 1, 0, 0, 0, 225, 2167, 1, 0, 0, 0, 227, 2172, + 1, 0, 0, 0, 229, 2179, 1, 0, 0, 0, 231, 2187, 1, 0, 0, 0, 233, 2193, 1, + 0, 0, 0, 235, 2198, 1, 0, 0, 0, 237, 2205, 1, 0, 0, 0, 239, 2210, 1, 0, + 0, 0, 241, 2215, 1, 0, 0, 0, 243, 2220, 1, 0, 0, 0, 245, 2225, 1, 0, 0, + 0, 247, 2231, 1, 0, 0, 0, 249, 2241, 1, 0, 0, 0, 251, 2250, 1, 0, 0, 0, + 253, 2259, 1, 0, 0, 0, 255, 2267, 1, 0, 0, 0, 257, 2275, 1, 0, 0, 0, 259, + 2283, 1, 0, 0, 0, 261, 2288, 1, 0, 0, 0, 263, 2295, 1, 0, 0, 0, 265, 2302, + 1, 0, 0, 0, 267, 2307, 1, 0, 0, 0, 269, 2315, 1, 0, 0, 0, 271, 2321, 1, + 0, 0, 0, 273, 2330, 1, 0, 0, 0, 275, 2335, 1, 0, 0, 0, 277, 2341, 1, 0, + 0, 0, 279, 2348, 1, 0, 0, 0, 281, 2356, 1, 0, 0, 0, 283, 2362, 1, 0, 0, + 0, 285, 2370, 1, 0, 0, 0, 287, 2379, 1, 0, 0, 0, 289, 2389, 1, 0, 0, 0, + 291, 2401, 1, 0, 0, 0, 293, 2413, 1, 0, 0, 0, 295, 2424, 1, 0, 0, 0, 297, + 2433, 1, 0, 0, 0, 299, 2442, 1, 0, 0, 0, 301, 2451, 1, 0, 0, 0, 303, 2459, + 1, 0, 0, 0, 305, 2469, 1, 0, 0, 0, 307, 2473, 1, 0, 0, 0, 309, 2478, 1, + 0, 0, 0, 311, 2489, 1, 0, 0, 0, 313, 2496, 1, 0, 0, 0, 315, 2506, 1, 0, + 0, 0, 317, 2521, 1, 0, 0, 0, 319, 2534, 1, 0, 0, 0, 321, 2545, 1, 0, 0, + 0, 323, 2552, 1, 0, 0, 0, 325, 2558, 1, 0, 0, 0, 327, 2570, 1, 0, 0, 0, + 329, 2578, 1, 0, 0, 0, 331, 2589, 1, 0, 0, 0, 333, 2595, 1, 0, 0, 0, 335, + 2603, 1, 0, 0, 0, 337, 2612, 1, 0, 0, 0, 339, 2623, 1, 0, 0, 0, 341, 2636, + 1, 0, 0, 0, 343, 2645, 1, 0, 0, 0, 345, 2654, 1, 0, 0, 0, 347, 2663, 1, + 0, 0, 0, 349, 2681, 1, 0, 0, 0, 351, 2707, 1, 0, 0, 0, 353, 2717, 1, 0, + 0, 0, 355, 2728, 1, 0, 0, 0, 357, 2741, 1, 0, 0, 0, 359, 2752, 1, 0, 0, + 0, 361, 2765, 1, 0, 0, 0, 363, 2780, 1, 0, 0, 0, 365, 2791, 1, 0, 0, 0, + 367, 2798, 1, 0, 0, 0, 369, 2805, 1, 0, 0, 0, 371, 2813, 1, 0, 0, 0, 373, + 2821, 1, 0, 0, 0, 375, 2826, 1, 0, 0, 0, 377, 2834, 1, 0, 0, 0, 379, 2845, + 1, 0, 0, 0, 381, 2852, 1, 0, 0, 0, 383, 2862, 1, 0, 0, 0, 385, 2869, 1, + 0, 0, 0, 387, 2876, 1, 0, 0, 0, 389, 2884, 1, 0, 0, 0, 391, 2895, 1, 0, + 0, 0, 393, 2901, 1, 0, 0, 0, 395, 2906, 1, 0, 0, 0, 397, 2920, 1, 0, 0, + 0, 399, 2934, 1, 0, 0, 0, 401, 2941, 1, 0, 0, 0, 403, 2951, 1, 0, 0, 0, + 405, 2964, 1, 0, 0, 0, 407, 2970, 1, 0, 0, 0, 409, 2976, 1, 0, 0, 0, 411, + 2988, 1, 0, 0, 0, 413, 2995, 1, 0, 0, 0, 415, 3006, 1, 0, 0, 0, 417, 3023, + 1, 0, 0, 0, 419, 3031, 1, 0, 0, 0, 421, 3037, 1, 0, 0, 0, 423, 3043, 1, + 0, 0, 0, 425, 3050, 1, 0, 0, 0, 427, 3059, 1, 0, 0, 0, 429, 3063, 1, 0, + 0, 0, 431, 3070, 1, 0, 0, 0, 433, 3078, 1, 0, 0, 0, 435, 3086, 1, 0, 0, + 0, 437, 3095, 1, 0, 0, 0, 439, 3104, 1, 0, 0, 0, 441, 3115, 1, 0, 0, 0, + 443, 3126, 1, 0, 0, 0, 445, 3132, 1, 0, 0, 0, 447, 3144, 1, 0, 0, 0, 449, + 3157, 1, 0, 0, 0, 451, 3173, 1, 0, 0, 0, 453, 3182, 1, 0, 0, 0, 455, 3190, + 1, 0, 0, 0, 457, 3202, 1, 0, 0, 0, 459, 3215, 1, 0, 0, 0, 461, 3230, 1, + 0, 0, 0, 463, 3241, 1, 0, 0, 0, 465, 3251, 1, 0, 0, 0, 467, 3265, 1, 0, + 0, 0, 469, 3279, 1, 0, 0, 0, 471, 3293, 1, 0, 0, 0, 473, 3308, 1, 0, 0, + 0, 475, 3322, 1, 0, 0, 0, 477, 3332, 1, 0, 0, 0, 479, 3341, 1, 0, 0, 0, + 481, 3348, 1, 0, 0, 0, 483, 3356, 1, 0, 0, 0, 485, 3364, 1, 0, 0, 0, 487, + 3371, 1, 0, 0, 0, 489, 3379, 1, 0, 0, 0, 491, 3384, 1, 0, 0, 0, 493, 3393, + 1, 0, 0, 0, 495, 3401, 1, 0, 0, 0, 497, 3410, 1, 0, 0, 0, 499, 3419, 1, + 0, 0, 0, 501, 3422, 1, 0, 0, 0, 503, 3425, 1, 0, 0, 0, 505, 3428, 1, 0, + 0, 0, 507, 3431, 1, 0, 0, 0, 509, 3434, 1, 0, 0, 0, 511, 3437, 1, 0, 0, + 0, 513, 3447, 1, 0, 0, 0, 515, 3454, 1, 0, 0, 0, 517, 3462, 1, 0, 0, 0, + 519, 3467, 1, 0, 0, 0, 521, 3475, 1, 0, 0, 0, 523, 3483, 1, 0, 0, 0, 525, + 3492, 1, 0, 0, 0, 527, 3497, 1, 0, 0, 0, 529, 3508, 1, 0, 0, 0, 531, 3515, + 1, 0, 0, 0, 533, 3528, 1, 0, 0, 0, 535, 3537, 1, 0, 0, 0, 537, 3543, 1, + 0, 0, 0, 539, 3558, 1, 0, 0, 0, 541, 3563, 1, 0, 0, 0, 543, 3569, 1, 0, + 0, 0, 545, 3573, 1, 0, 0, 0, 547, 3577, 1, 0, 0, 0, 549, 3581, 1, 0, 0, + 0, 551, 3585, 1, 0, 0, 0, 553, 3592, 1, 0, 0, 0, 555, 3597, 1, 0, 0, 0, + 557, 3606, 1, 0, 0, 0, 559, 3611, 1, 0, 0, 0, 561, 3615, 1, 0, 0, 0, 563, + 3618, 1, 0, 0, 0, 565, 3622, 1, 0, 0, 0, 567, 3627, 1, 0, 0, 0, 569, 3630, + 1, 0, 0, 0, 571, 3638, 1, 0, 0, 0, 573, 3643, 1, 0, 0, 0, 575, 3649, 1, + 0, 0, 0, 577, 3656, 1, 0, 0, 0, 579, 3663, 1, 0, 0, 0, 581, 3671, 1, 0, + 0, 0, 583, 3676, 1, 0, 0, 0, 585, 3682, 1, 0, 0, 0, 587, 3693, 1, 0, 0, + 0, 589, 3702, 1, 0, 0, 0, 591, 3707, 1, 0, 0, 0, 593, 3716, 1, 0, 0, 0, + 595, 3722, 1, 0, 0, 0, 597, 3728, 1, 0, 0, 0, 599, 3734, 1, 0, 0, 0, 601, + 3740, 1, 0, 0, 0, 603, 3748, 1, 0, 0, 0, 605, 3759, 1, 0, 0, 0, 607, 3765, + 1, 0, 0, 0, 609, 3776, 1, 0, 0, 0, 611, 3787, 1, 0, 0, 0, 613, 3792, 1, + 0, 0, 0, 615, 3800, 1, 0, 0, 0, 617, 3809, 1, 0, 0, 0, 619, 3815, 1, 0, + 0, 0, 621, 3820, 1, 0, 0, 0, 623, 3825, 1, 0, 0, 0, 625, 3840, 1, 0, 0, + 0, 627, 3846, 1, 0, 0, 0, 629, 3854, 1, 0, 0, 0, 631, 3860, 1, 0, 0, 0, + 633, 3870, 1, 0, 0, 0, 635, 3877, 1, 0, 0, 0, 637, 3882, 1, 0, 0, 0, 639, + 3890, 1, 0, 0, 0, 641, 3895, 1, 0, 0, 0, 643, 3904, 1, 0, 0, 0, 645, 3912, + 1, 0, 0, 0, 647, 3917, 1, 0, 0, 0, 649, 3921, 1, 0, 0, 0, 651, 3928, 1, + 0, 0, 0, 653, 3936, 1, 0, 0, 0, 655, 3940, 1, 0, 0, 0, 657, 3945, 1, 0, + 0, 0, 659, 3949, 1, 0, 0, 0, 661, 3955, 1, 0, 0, 0, 663, 3959, 1, 0, 0, + 0, 665, 3966, 1, 0, 0, 0, 667, 3974, 1, 0, 0, 0, 669, 3982, 1, 0, 0, 0, + 671, 3989, 1, 0, 0, 0, 673, 3999, 1, 0, 0, 0, 675, 4007, 1, 0, 0, 0, 677, + 4013, 1, 0, 0, 0, 679, 4020, 1, 0, 0, 0, 681, 4034, 1, 0, 0, 0, 683, 4043, + 1, 0, 0, 0, 685, 4052, 1, 0, 0, 0, 687, 4063, 1, 0, 0, 0, 689, 4072, 1, + 0, 0, 0, 691, 4078, 1, 0, 0, 0, 693, 4082, 1, 0, 0, 0, 695, 4090, 1, 0, + 0, 0, 697, 4097, 1, 0, 0, 0, 699, 4102, 1, 0, 0, 0, 701, 4108, 1, 0, 0, + 0, 703, 4113, 1, 0, 0, 0, 705, 4120, 1, 0, 0, 0, 707, 4129, 1, 0, 0, 0, + 709, 4139, 1, 0, 0, 0, 711, 4144, 1, 0, 0, 0, 713, 4151, 1, 0, 0, 0, 715, + 4157, 1, 0, 0, 0, 717, 4165, 1, 0, 0, 0, 719, 4175, 1, 0, 0, 0, 721, 4186, + 1, 0, 0, 0, 723, 4194, 1, 0, 0, 0, 725, 4205, 1, 0, 0, 0, 727, 4210, 1, + 0, 0, 0, 729, 4216, 1, 0, 0, 0, 731, 4221, 1, 0, 0, 0, 733, 4227, 1, 0, + 0, 0, 735, 4233, 1, 0, 0, 0, 737, 4241, 1, 0, 0, 0, 739, 4250, 1, 0, 0, + 0, 741, 4263, 1, 0, 0, 0, 743, 4274, 1, 0, 0, 0, 745, 4284, 1, 0, 0, 0, + 747, 4294, 1, 0, 0, 0, 749, 4307, 1, 0, 0, 0, 751, 4317, 1, 0, 0, 0, 753, + 4329, 1, 0, 0, 0, 755, 4336, 1, 0, 0, 0, 757, 4345, 1, 0, 0, 0, 759, 4355, + 1, 0, 0, 0, 761, 4362, 1, 0, 0, 0, 763, 4369, 1, 0, 0, 0, 765, 4375, 1, + 0, 0, 0, 767, 4382, 1, 0, 0, 0, 769, 4390, 1, 0, 0, 0, 771, 4396, 1, 0, + 0, 0, 773, 4402, 1, 0, 0, 0, 775, 4410, 1, 0, 0, 0, 777, 4417, 1, 0, 0, + 0, 779, 4422, 1, 0, 0, 0, 781, 4428, 1, 0, 0, 0, 783, 4433, 1, 0, 0, 0, + 785, 4439, 1, 0, 0, 0, 787, 4447, 1, 0, 0, 0, 789, 4455, 1, 0, 0, 0, 791, + 4463, 1, 0, 0, 0, 793, 4469, 1, 0, 0, 0, 795, 4480, 1, 0, 0, 0, 797, 4488, + 1, 0, 0, 0, 799, 4496, 1, 0, 0, 0, 801, 4507, 1, 0, 0, 0, 803, 4518, 1, + 0, 0, 0, 805, 4525, 1, 0, 0, 0, 807, 4531, 1, 0, 0, 0, 809, 4541, 1, 0, + 0, 0, 811, 4546, 1, 0, 0, 0, 813, 4552, 1, 0, 0, 0, 815, 4559, 1, 0, 0, + 0, 817, 4568, 1, 0, 0, 0, 819, 4573, 1, 0, 0, 0, 821, 4578, 1, 0, 0, 0, + 823, 4581, 1, 0, 0, 0, 825, 4584, 1, 0, 0, 0, 827, 4589, 1, 0, 0, 0, 829, + 4593, 1, 0, 0, 0, 831, 4601, 1, 0, 0, 0, 833, 4609, 1, 0, 0, 0, 835, 4623, + 1, 0, 0, 0, 837, 4630, 1, 0, 0, 0, 839, 4634, 1, 0, 0, 0, 841, 4642, 1, + 0, 0, 0, 843, 4646, 1, 0, 0, 0, 845, 4650, 1, 0, 0, 0, 847, 4661, 1, 0, + 0, 0, 849, 4664, 1, 0, 0, 0, 851, 4673, 1, 0, 0, 0, 853, 4679, 1, 0, 0, + 0, 855, 4689, 1, 0, 0, 0, 857, 4698, 1, 0, 0, 0, 859, 4712, 1, 0, 0, 0, + 861, 4721, 1, 0, 0, 0, 863, 4726, 1, 0, 0, 0, 865, 4732, 1, 0, 0, 0, 867, + 4738, 1, 0, 0, 0, 869, 4745, 1, 0, 0, 0, 871, 4756, 1, 0, 0, 0, 873, 4766, + 1, 0, 0, 0, 875, 4773, 1, 0, 0, 0, 877, 4778, 1, 0, 0, 0, 879, 4785, 1, + 0, 0, 0, 881, 4791, 1, 0, 0, 0, 883, 4798, 1, 0, 0, 0, 885, 4804, 1, 0, + 0, 0, 887, 4809, 1, 0, 0, 0, 889, 4814, 1, 0, 0, 0, 891, 4823, 1, 0, 0, + 0, 893, 4829, 1, 0, 0, 0, 895, 4838, 1, 0, 0, 0, 897, 4848, 1, 0, 0, 0, + 899, 4861, 1, 0, 0, 0, 901, 4867, 1, 0, 0, 0, 903, 4872, 1, 0, 0, 0, 905, + 4876, 1, 0, 0, 0, 907, 4885, 1, 0, 0, 0, 909, 4890, 1, 0, 0, 0, 911, 4899, + 1, 0, 0, 0, 913, 4904, 1, 0, 0, 0, 915, 4915, 1, 0, 0, 0, 917, 4924, 1, + 0, 0, 0, 919, 4937, 1, 0, 0, 0, 921, 4941, 1, 0, 0, 0, 923, 4947, 1, 0, + 0, 0, 925, 4950, 1, 0, 0, 0, 927, 4955, 1, 0, 0, 0, 929, 4961, 1, 0, 0, + 0, 931, 4973, 1, 0, 0, 0, 933, 4981, 1, 0, 0, 0, 935, 4985, 1, 0, 0, 0, + 937, 4995, 1, 0, 0, 0, 939, 4997, 1, 0, 0, 0, 941, 5000, 1, 0, 0, 0, 943, + 5003, 1, 0, 0, 0, 945, 5005, 1, 0, 0, 0, 947, 5007, 1, 0, 0, 0, 949, 5009, + 1, 0, 0, 0, 951, 5011, 1, 0, 0, 0, 953, 5013, 1, 0, 0, 0, 955, 5015, 1, + 0, 0, 0, 957, 5017, 1, 0, 0, 0, 959, 5019, 1, 0, 0, 0, 961, 5023, 1, 0, + 0, 0, 963, 5027, 1, 0, 0, 0, 965, 5029, 1, 0, 0, 0, 967, 5031, 1, 0, 0, + 0, 969, 5033, 1, 0, 0, 0, 971, 5035, 1, 0, 0, 0, 973, 5037, 1, 0, 0, 0, + 975, 5039, 1, 0, 0, 0, 977, 5041, 1, 0, 0, 0, 979, 5043, 1, 0, 0, 0, 981, + 5045, 1, 0, 0, 0, 983, 5047, 1, 0, 0, 0, 985, 5049, 1, 0, 0, 0, 987, 5051, + 1, 0, 0, 0, 989, 5054, 1, 0, 0, 0, 991, 5057, 1, 0, 0, 0, 993, 5059, 1, + 0, 0, 0, 995, 5061, 1, 0, 0, 0, 997, 5073, 1, 0, 0, 0, 999, 5086, 1, 0, + 0, 0, 1001, 5099, 1, 0, 0, 0, 1003, 5125, 1, 0, 0, 0, 1005, 5131, 1, 0, + 0, 0, 1007, 5138, 1, 0, 0, 0, 1009, 5172, 1, 0, 0, 0, 1011, 5174, 1, 0, + 0, 0, 1013, 5176, 1, 0, 0, 0, 1015, 5178, 1, 0, 0, 0, 1017, 5180, 1, 0, + 0, 0, 1019, 5182, 1, 0, 0, 0, 1021, 5184, 1, 0, 0, 0, 1023, 5186, 1, 0, + 0, 0, 1025, 5188, 1, 0, 0, 0, 1027, 5190, 1, 0, 0, 0, 1029, 5192, 1, 0, + 0, 0, 1031, 5194, 1, 0, 0, 0, 1033, 5196, 1, 0, 0, 0, 1035, 5198, 1, 0, + 0, 0, 1037, 5200, 1, 0, 0, 0, 1039, 5202, 1, 0, 0, 0, 1041, 5204, 1, 0, + 0, 0, 1043, 5206, 1, 0, 0, 0, 1045, 5208, 1, 0, 0, 0, 1047, 5210, 1, 0, + 0, 0, 1049, 5212, 1, 0, 0, 0, 1051, 5214, 1, 0, 0, 0, 1053, 5216, 1, 0, + 0, 0, 1055, 5218, 1, 0, 0, 0, 1057, 5220, 1, 0, 0, 0, 1059, 5222, 1, 0, + 0, 0, 1061, 5224, 1, 0, 0, 0, 1063, 5226, 1, 0, 0, 0, 1065, 5228, 1, 0, + 0, 0, 1067, 5230, 1, 0, 0, 0, 1069, 1071, 7, 0, 0, 0, 1070, 1069, 1, 0, + 0, 0, 1071, 1072, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1072, 1073, 1, 0, + 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1075, 6, 0, 0, 0, 1075, 2, 1, 0, 0, + 0, 1076, 1077, 5, 47, 0, 0, 1077, 1078, 5, 42, 0, 0, 1078, 1079, 5, 42, + 0, 0, 1079, 1083, 1, 0, 0, 0, 1080, 1082, 9, 0, 0, 0, 1081, 1080, 1, 0, + 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1083, 1081, 1, 0, + 0, 0, 1084, 1086, 1, 0, 0, 0, 1085, 1083, 1, 0, 0, 0, 1086, 1087, 5, 42, + 0, 0, 1087, 1088, 5, 47, 0, 0, 1088, 4, 1, 0, 0, 0, 1089, 1090, 5, 47, + 0, 0, 1090, 1091, 5, 42, 0, 0, 1091, 1095, 1, 0, 0, 0, 1092, 1094, 9, 0, + 0, 0, 1093, 1092, 1, 0, 0, 0, 1094, 1097, 1, 0, 0, 0, 1095, 1096, 1, 0, + 0, 0, 1095, 1093, 1, 0, 0, 0, 1096, 1098, 1, 0, 0, 0, 1097, 1095, 1, 0, + 0, 0, 1098, 1099, 5, 42, 0, 0, 1099, 1100, 5, 47, 0, 0, 1100, 1101, 1, + 0, 0, 0, 1101, 1102, 6, 2, 0, 0, 1102, 6, 1, 0, 0, 0, 1103, 1104, 5, 45, + 0, 0, 1104, 1105, 5, 45, 0, 0, 1105, 1109, 1, 0, 0, 0, 1106, 1108, 8, 1, + 0, 0, 1107, 1106, 1, 0, 0, 0, 1108, 1111, 1, 0, 0, 0, 1109, 1107, 1, 0, + 0, 0, 1109, 1110, 1, 0, 0, 0, 1110, 1112, 1, 0, 0, 0, 1111, 1109, 1, 0, + 0, 0, 1112, 1113, 6, 3, 0, 0, 1113, 8, 1, 0, 0, 0, 1114, 1115, 3, 1033, + 516, 0, 1115, 1117, 3, 1053, 526, 0, 1116, 1118, 3, 1, 0, 0, 1117, 1116, + 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1117, 1, 0, 0, 0, 1119, 1120, + 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1122, 3, 1043, 521, 0, 1122, + 1123, 3, 1045, 522, 0, 1123, 1125, 3, 1055, 527, 0, 1124, 1126, 3, 1, 0, + 0, 1125, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1125, 1, 0, 0, + 0, 1127, 1128, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 1130, 3, 1043, + 521, 0, 1130, 1131, 3, 1057, 528, 0, 1131, 1132, 3, 1039, 519, 0, 1132, + 1133, 3, 1039, 519, 0, 1133, 10, 1, 0, 0, 0, 1134, 1135, 3, 1033, 516, + 0, 1135, 1137, 3, 1053, 526, 0, 1136, 1138, 3, 1, 0, 0, 1137, 1136, 1, + 0, 0, 0, 1138, 1139, 1, 0, 0, 0, 1139, 1137, 1, 0, 0, 0, 1139, 1140, 1, + 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1142, 3, 1043, 521, 0, 1142, 1143, + 3, 1057, 528, 0, 1143, 1144, 3, 1039, 519, 0, 1144, 1145, 3, 1039, 519, + 0, 1145, 12, 1, 0, 0, 0, 1146, 1147, 3, 1043, 521, 0, 1147, 1148, 3, 1045, + 522, 0, 1148, 1150, 3, 1055, 527, 0, 1149, 1151, 3, 1, 0, 0, 1150, 1149, + 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1150, 1, 0, 0, 0, 1152, 1153, + 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1155, 3, 1043, 521, 0, 1155, + 1156, 3, 1057, 528, 0, 1156, 1157, 3, 1039, 519, 0, 1157, 1158, 3, 1039, + 519, 0, 1158, 14, 1, 0, 0, 0, 1159, 1160, 3, 1029, 514, 0, 1160, 1161, + 3, 1051, 525, 0, 1161, 1162, 3, 1045, 522, 0, 1162, 1163, 3, 1057, 528, + 0, 1163, 1165, 3, 1047, 523, 0, 1164, 1166, 3, 1, 0, 0, 1165, 1164, 1, + 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1165, 1, 0, 0, 0, 1167, 1168, 1, + 0, 0, 0, 1168, 1169, 1, 0, 0, 0, 1169, 1170, 3, 1019, 509, 0, 1170, 1171, + 3, 1065, 532, 0, 1171, 16, 1, 0, 0, 0, 1172, 1173, 3, 1045, 522, 0, 1173, + 1174, 3, 1051, 525, 0, 1174, 1175, 3, 1023, 511, 0, 1175, 1176, 3, 1025, + 512, 0, 1176, 1178, 3, 1051, 525, 0, 1177, 1179, 3, 1, 0, 0, 1178, 1177, + 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1180, 1181, + 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1183, 3, 1019, 509, 0, 1183, + 1184, 3, 1065, 532, 0, 1184, 18, 1, 0, 0, 0, 1185, 1186, 3, 1053, 526, + 0, 1186, 1187, 3, 1045, 522, 0, 1187, 1188, 3, 1051, 525, 0, 1188, 1190, + 3, 1055, 527, 0, 1189, 1191, 3, 1, 0, 0, 1190, 1189, 1, 0, 0, 0, 1191, + 1192, 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, + 1194, 1, 0, 0, 0, 1194, 1195, 3, 1019, 509, 0, 1195, 1196, 3, 1065, 532, + 0, 1196, 20, 1, 0, 0, 0, 1197, 1198, 3, 1043, 521, 0, 1198, 1199, 3, 1045, + 522, 0, 1199, 1200, 3, 1043, 521, 0, 1200, 1201, 5, 45, 0, 0, 1201, 1202, + 3, 1047, 523, 0, 1202, 1203, 3, 1025, 512, 0, 1203, 1204, 3, 1051, 525, + 0, 1204, 1205, 3, 1053, 526, 0, 1205, 1206, 3, 1033, 516, 0, 1206, 1207, + 3, 1053, 526, 0, 1207, 1208, 3, 1055, 527, 0, 1208, 1209, 3, 1025, 512, + 0, 1209, 1210, 3, 1043, 521, 0, 1210, 1211, 3, 1055, 527, 0, 1211, 22, + 1, 0, 0, 0, 1212, 1213, 3, 1051, 525, 0, 1213, 1214, 3, 1025, 512, 0, 1214, + 1215, 3, 1027, 513, 0, 1215, 1216, 3, 1025, 512, 0, 1216, 1217, 3, 1051, + 525, 0, 1217, 1218, 3, 1025, 512, 0, 1218, 1219, 3, 1043, 521, 0, 1219, + 1220, 3, 1021, 510, 0, 1220, 1222, 3, 1025, 512, 0, 1221, 1223, 5, 95, + 0, 0, 1222, 1221, 1, 0, 0, 0, 1222, 1223, 1, 0, 0, 0, 1223, 1224, 1, 0, + 0, 0, 1224, 1225, 3, 1053, 526, 0, 1225, 1226, 3, 1025, 512, 0, 1226, 1227, + 3, 1055, 527, 0, 1227, 24, 1, 0, 0, 0, 1228, 1229, 3, 1039, 519, 0, 1229, + 1230, 3, 1033, 516, 0, 1230, 1231, 3, 1053, 526, 0, 1231, 1233, 3, 1055, + 527, 0, 1232, 1234, 3, 1, 0, 0, 1233, 1232, 1, 0, 0, 0, 1234, 1235, 1, + 0, 0, 0, 1235, 1233, 1, 0, 0, 0, 1235, 1236, 1, 0, 0, 0, 1236, 1237, 1, + 0, 0, 0, 1237, 1238, 3, 1045, 522, 0, 1238, 1239, 3, 1027, 513, 0, 1239, + 26, 1, 0, 0, 0, 1240, 1241, 3, 1023, 511, 0, 1241, 1242, 3, 1025, 512, + 0, 1242, 1243, 3, 1039, 519, 0, 1243, 1244, 3, 1025, 512, 0, 1244, 1245, + 3, 1055, 527, 0, 1245, 1247, 3, 1025, 512, 0, 1246, 1248, 3, 1, 0, 0, 1247, + 1246, 1, 0, 0, 0, 1248, 1249, 1, 0, 0, 0, 1249, 1247, 1, 0, 0, 0, 1249, + 1250, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 1252, 3, 1017, 508, 0, + 1252, 1253, 3, 1043, 521, 0, 1253, 1255, 3, 1023, 511, 0, 1254, 1256, 3, + 1, 0, 0, 1255, 1254, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 1255, 1, + 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1259, 1, 0, 0, 0, 1259, 1260, 3, + 1051, 525, 0, 1260, 1261, 3, 1025, 512, 0, 1261, 1262, 3, 1027, 513, 0, + 1262, 1263, 3, 1025, 512, 0, 1263, 1264, 3, 1051, 525, 0, 1264, 1265, 3, + 1025, 512, 0, 1265, 1266, 3, 1043, 521, 0, 1266, 1267, 3, 1021, 510, 0, + 1267, 1268, 3, 1025, 512, 0, 1268, 1269, 3, 1053, 526, 0, 1269, 1313, 1, + 0, 0, 0, 1270, 1271, 3, 1023, 511, 0, 1271, 1272, 3, 1025, 512, 0, 1272, + 1273, 3, 1039, 519, 0, 1273, 1274, 3, 1025, 512, 0, 1274, 1275, 3, 1055, + 527, 0, 1275, 1276, 3, 1025, 512, 0, 1276, 1277, 5, 95, 0, 0, 1277, 1278, + 3, 1017, 508, 0, 1278, 1279, 3, 1043, 521, 0, 1279, 1280, 3, 1023, 511, + 0, 1280, 1281, 5, 95, 0, 0, 1281, 1282, 3, 1051, 525, 0, 1282, 1283, 3, + 1025, 512, 0, 1283, 1284, 3, 1027, 513, 0, 1284, 1285, 3, 1025, 512, 0, + 1285, 1286, 3, 1051, 525, 0, 1286, 1287, 3, 1025, 512, 0, 1287, 1288, 3, + 1043, 521, 0, 1288, 1289, 3, 1021, 510, 0, 1289, 1290, 3, 1025, 512, 0, + 1290, 1291, 3, 1053, 526, 0, 1291, 1313, 1, 0, 0, 0, 1292, 1293, 3, 1023, + 511, 0, 1293, 1294, 3, 1025, 512, 0, 1294, 1295, 3, 1039, 519, 0, 1295, + 1296, 3, 1025, 512, 0, 1296, 1297, 3, 1055, 527, 0, 1297, 1298, 3, 1025, + 512, 0, 1298, 1299, 3, 1017, 508, 0, 1299, 1300, 3, 1043, 521, 0, 1300, + 1301, 3, 1023, 511, 0, 1301, 1302, 3, 1051, 525, 0, 1302, 1303, 3, 1025, + 512, 0, 1303, 1304, 3, 1027, 513, 0, 1304, 1305, 3, 1025, 512, 0, 1305, + 1306, 3, 1051, 525, 0, 1306, 1307, 3, 1025, 512, 0, 1307, 1308, 3, 1043, + 521, 0, 1308, 1309, 3, 1021, 510, 0, 1309, 1310, 3, 1025, 512, 0, 1310, + 1311, 3, 1053, 526, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1240, 1, 0, 0, 0, + 1312, 1270, 1, 0, 0, 0, 1312, 1292, 1, 0, 0, 0, 1313, 28, 1, 0, 0, 0, 1314, + 1315, 3, 1023, 511, 0, 1315, 1316, 3, 1025, 512, 0, 1316, 1317, 3, 1039, + 519, 0, 1317, 1318, 3, 1025, 512, 0, 1318, 1319, 3, 1055, 527, 0, 1319, + 1321, 3, 1025, 512, 0, 1320, 1322, 3, 1, 0, 0, 1321, 1320, 1, 0, 0, 0, + 1322, 1323, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1323, 1324, 1, 0, 0, 0, + 1324, 1325, 1, 0, 0, 0, 1325, 1326, 3, 1019, 509, 0, 1326, 1327, 3, 1057, + 528, 0, 1327, 1329, 3, 1055, 527, 0, 1328, 1330, 3, 1, 0, 0, 1329, 1328, + 1, 0, 0, 0, 1330, 1331, 1, 0, 0, 0, 1331, 1329, 1, 0, 0, 0, 1331, 1332, + 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1334, 3, 1037, 518, 0, 1334, + 1335, 3, 1025, 512, 0, 1335, 1336, 3, 1025, 512, 0, 1336, 1338, 3, 1047, + 523, 0, 1337, 1339, 3, 1, 0, 0, 1338, 1337, 1, 0, 0, 0, 1339, 1340, 1, + 0, 0, 0, 1340, 1338, 1, 0, 0, 0, 1340, 1341, 1, 0, 0, 0, 1341, 1342, 1, + 0, 0, 0, 1342, 1343, 3, 1051, 525, 0, 1343, 1344, 3, 1025, 512, 0, 1344, + 1345, 3, 1027, 513, 0, 1345, 1346, 3, 1025, 512, 0, 1346, 1347, 3, 1051, + 525, 0, 1347, 1348, 3, 1025, 512, 0, 1348, 1349, 3, 1043, 521, 0, 1349, + 1350, 3, 1021, 510, 0, 1350, 1351, 3, 1025, 512, 0, 1351, 1352, 3, 1053, + 526, 0, 1352, 1405, 1, 0, 0, 0, 1353, 1354, 3, 1023, 511, 0, 1354, 1355, + 3, 1025, 512, 0, 1355, 1356, 3, 1039, 519, 0, 1356, 1357, 3, 1025, 512, + 0, 1357, 1358, 3, 1055, 527, 0, 1358, 1359, 3, 1025, 512, 0, 1359, 1360, + 5, 95, 0, 0, 1360, 1361, 3, 1019, 509, 0, 1361, 1362, 3, 1057, 528, 0, + 1362, 1363, 3, 1055, 527, 0, 1363, 1364, 5, 95, 0, 0, 1364, 1365, 3, 1037, + 518, 0, 1365, 1366, 3, 1025, 512, 0, 1366, 1367, 3, 1025, 512, 0, 1367, + 1368, 3, 1047, 523, 0, 1368, 1369, 5, 95, 0, 0, 1369, 1370, 3, 1051, 525, + 0, 1370, 1371, 3, 1025, 512, 0, 1371, 1372, 3, 1027, 513, 0, 1372, 1373, + 3, 1025, 512, 0, 1373, 1374, 3, 1051, 525, 0, 1374, 1375, 3, 1025, 512, + 0, 1375, 1376, 3, 1043, 521, 0, 1376, 1377, 3, 1021, 510, 0, 1377, 1378, + 3, 1025, 512, 0, 1378, 1379, 3, 1053, 526, 0, 1379, 1405, 1, 0, 0, 0, 1380, + 1381, 3, 1023, 511, 0, 1381, 1382, 3, 1025, 512, 0, 1382, 1383, 3, 1039, + 519, 0, 1383, 1384, 3, 1025, 512, 0, 1384, 1385, 3, 1055, 527, 0, 1385, + 1386, 3, 1025, 512, 0, 1386, 1387, 3, 1019, 509, 0, 1387, 1388, 3, 1057, + 528, 0, 1388, 1389, 3, 1055, 527, 0, 1389, 1390, 3, 1037, 518, 0, 1390, + 1391, 3, 1025, 512, 0, 1391, 1392, 3, 1025, 512, 0, 1392, 1393, 3, 1047, + 523, 0, 1393, 1394, 3, 1051, 525, 0, 1394, 1395, 3, 1025, 512, 0, 1395, + 1396, 3, 1027, 513, 0, 1396, 1397, 3, 1025, 512, 0, 1397, 1398, 3, 1051, + 525, 0, 1398, 1399, 3, 1025, 512, 0, 1399, 1400, 3, 1043, 521, 0, 1400, + 1401, 3, 1021, 510, 0, 1401, 1402, 3, 1025, 512, 0, 1402, 1403, 3, 1053, + 526, 0, 1403, 1405, 1, 0, 0, 0, 1404, 1314, 1, 0, 0, 0, 1404, 1353, 1, + 0, 0, 0, 1404, 1380, 1, 0, 0, 0, 1405, 30, 1, 0, 0, 0, 1406, 1407, 3, 1023, + 511, 0, 1407, 1408, 3, 1025, 512, 0, 1408, 1409, 3, 1039, 519, 0, 1409, + 1410, 3, 1025, 512, 0, 1410, 1411, 3, 1055, 527, 0, 1411, 1413, 3, 1025, + 512, 0, 1412, 1414, 3, 1, 0, 0, 1413, 1412, 1, 0, 0, 0, 1414, 1415, 1, + 0, 0, 0, 1415, 1413, 1, 0, 0, 0, 1415, 1416, 1, 0, 0, 0, 1416, 1417, 1, + 0, 0, 0, 1417, 1418, 3, 1033, 516, 0, 1418, 1420, 3, 1027, 513, 0, 1419, + 1421, 3, 1, 0, 0, 1420, 1419, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, + 1420, 1, 0, 0, 0, 1422, 1423, 1, 0, 0, 0, 1423, 1424, 1, 0, 0, 0, 1424, + 1425, 3, 1043, 521, 0, 1425, 1427, 3, 1045, 522, 0, 1426, 1428, 3, 1, 0, + 0, 1427, 1426, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 1427, 1, 0, 0, + 0, 1429, 1430, 1, 0, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 1432, 3, 1051, + 525, 0, 1432, 1433, 3, 1025, 512, 0, 1433, 1434, 3, 1027, 513, 0, 1434, + 1435, 3, 1025, 512, 0, 1435, 1436, 3, 1051, 525, 0, 1436, 1437, 3, 1025, + 512, 0, 1437, 1438, 3, 1043, 521, 0, 1438, 1439, 3, 1021, 510, 0, 1439, + 1440, 3, 1025, 512, 0, 1440, 1441, 3, 1053, 526, 0, 1441, 1488, 1, 0, 0, + 0, 1442, 1443, 3, 1023, 511, 0, 1443, 1444, 3, 1025, 512, 0, 1444, 1445, + 3, 1039, 519, 0, 1445, 1446, 3, 1025, 512, 0, 1446, 1447, 3, 1055, 527, + 0, 1447, 1448, 3, 1025, 512, 0, 1448, 1449, 5, 95, 0, 0, 1449, 1450, 3, + 1033, 516, 0, 1450, 1451, 3, 1027, 513, 0, 1451, 1452, 5, 95, 0, 0, 1452, + 1453, 3, 1043, 521, 0, 1453, 1454, 3, 1045, 522, 0, 1454, 1455, 5, 95, + 0, 0, 1455, 1456, 3, 1051, 525, 0, 1456, 1457, 3, 1025, 512, 0, 1457, 1458, + 3, 1027, 513, 0, 1458, 1459, 3, 1025, 512, 0, 1459, 1460, 3, 1051, 525, + 0, 1460, 1461, 3, 1025, 512, 0, 1461, 1462, 3, 1043, 521, 0, 1462, 1463, + 3, 1021, 510, 0, 1463, 1464, 3, 1025, 512, 0, 1464, 1465, 3, 1053, 526, + 0, 1465, 1488, 1, 0, 0, 0, 1466, 1467, 3, 1023, 511, 0, 1467, 1468, 3, + 1025, 512, 0, 1468, 1469, 3, 1039, 519, 0, 1469, 1470, 3, 1025, 512, 0, + 1470, 1471, 3, 1055, 527, 0, 1471, 1472, 3, 1025, 512, 0, 1472, 1473, 3, + 1033, 516, 0, 1473, 1474, 3, 1027, 513, 0, 1474, 1475, 3, 1043, 521, 0, + 1475, 1476, 3, 1045, 522, 0, 1476, 1477, 3, 1051, 525, 0, 1477, 1478, 3, + 1025, 512, 0, 1478, 1479, 3, 1027, 513, 0, 1479, 1480, 3, 1025, 512, 0, + 1480, 1481, 3, 1051, 525, 0, 1481, 1482, 3, 1025, 512, 0, 1482, 1483, 3, + 1043, 521, 0, 1483, 1484, 3, 1021, 510, 0, 1484, 1485, 3, 1025, 512, 0, + 1485, 1486, 3, 1053, 526, 0, 1486, 1488, 1, 0, 0, 0, 1487, 1406, 1, 0, + 0, 0, 1487, 1442, 1, 0, 0, 0, 1487, 1466, 1, 0, 0, 0, 1488, 32, 1, 0, 0, + 0, 1489, 1490, 3, 1021, 510, 0, 1490, 1491, 3, 1051, 525, 0, 1491, 1492, + 3, 1025, 512, 0, 1492, 1493, 3, 1017, 508, 0, 1493, 1494, 3, 1055, 527, + 0, 1494, 1495, 3, 1025, 512, 0, 1495, 34, 1, 0, 0, 0, 1496, 1497, 3, 1017, + 508, 0, 1497, 1498, 3, 1039, 519, 0, 1498, 1499, 3, 1055, 527, 0, 1499, + 1500, 3, 1025, 512, 0, 1500, 1501, 3, 1051, 525, 0, 1501, 36, 1, 0, 0, + 0, 1502, 1503, 3, 1023, 511, 0, 1503, 1504, 3, 1051, 525, 0, 1504, 1505, + 3, 1045, 522, 0, 1505, 1506, 3, 1047, 523, 0, 1506, 38, 1, 0, 0, 0, 1507, + 1508, 3, 1051, 525, 0, 1508, 1509, 3, 1025, 512, 0, 1509, 1510, 3, 1043, + 521, 0, 1510, 1511, 3, 1017, 508, 0, 1511, 1512, 3, 1041, 520, 0, 1512, + 1513, 3, 1025, 512, 0, 1513, 40, 1, 0, 0, 0, 1514, 1515, 3, 1041, 520, + 0, 1515, 1516, 3, 1045, 522, 0, 1516, 1517, 3, 1059, 529, 0, 1517, 1518, + 3, 1025, 512, 0, 1518, 42, 1, 0, 0, 0, 1519, 1520, 3, 1041, 520, 0, 1520, + 1521, 3, 1045, 522, 0, 1521, 1522, 3, 1023, 511, 0, 1522, 1523, 3, 1033, + 516, 0, 1523, 1524, 3, 1027, 513, 0, 1524, 1525, 3, 1065, 532, 0, 1525, + 44, 1, 0, 0, 0, 1526, 1527, 3, 1025, 512, 0, 1527, 1528, 3, 1043, 521, + 0, 1528, 1529, 3, 1055, 527, 0, 1529, 1530, 3, 1033, 516, 0, 1530, 1531, + 3, 1055, 527, 0, 1531, 1532, 3, 1065, 532, 0, 1532, 46, 1, 0, 0, 0, 1533, + 1534, 3, 1047, 523, 0, 1534, 1535, 3, 1025, 512, 0, 1535, 1536, 3, 1051, + 525, 0, 1536, 1537, 3, 1053, 526, 0, 1537, 1538, 3, 1033, 516, 0, 1538, + 1539, 3, 1053, 526, 0, 1539, 1540, 3, 1055, 527, 0, 1540, 1541, 3, 1025, + 512, 0, 1541, 1542, 3, 1043, 521, 0, 1542, 1543, 3, 1055, 527, 0, 1543, + 48, 1, 0, 0, 0, 1544, 1545, 3, 1059, 529, 0, 1545, 1546, 3, 1033, 516, + 0, 1546, 1547, 3, 1025, 512, 0, 1547, 1548, 3, 1061, 530, 0, 1548, 50, + 1, 0, 0, 0, 1549, 1550, 3, 1025, 512, 0, 1550, 1551, 3, 1063, 531, 0, 1551, + 1552, 3, 1055, 527, 0, 1552, 1553, 3, 1025, 512, 0, 1553, 1554, 3, 1051, + 525, 0, 1554, 1555, 3, 1043, 521, 0, 1555, 1556, 3, 1017, 508, 0, 1556, + 1557, 3, 1039, 519, 0, 1557, 52, 1, 0, 0, 0, 1558, 1559, 3, 1017, 508, + 0, 1559, 1560, 3, 1053, 526, 0, 1560, 1561, 3, 1053, 526, 0, 1561, 1562, + 3, 1045, 522, 0, 1562, 1563, 3, 1021, 510, 0, 1563, 1564, 3, 1033, 516, + 0, 1564, 1565, 3, 1017, 508, 0, 1565, 1566, 3, 1055, 527, 0, 1566, 1567, + 3, 1033, 516, 0, 1567, 1568, 3, 1045, 522, 0, 1568, 1569, 3, 1043, 521, + 0, 1569, 54, 1, 0, 0, 0, 1570, 1571, 3, 1025, 512, 0, 1571, 1572, 3, 1043, + 521, 0, 1572, 1573, 3, 1057, 528, 0, 1573, 1574, 3, 1041, 520, 0, 1574, + 1575, 3, 1025, 512, 0, 1575, 1576, 3, 1051, 525, 0, 1576, 1577, 3, 1017, + 508, 0, 1577, 1578, 3, 1055, 527, 0, 1578, 1579, 3, 1033, 516, 0, 1579, + 1580, 3, 1045, 522, 0, 1580, 1581, 3, 1043, 521, 0, 1581, 56, 1, 0, 0, + 0, 1582, 1583, 3, 1041, 520, 0, 1583, 1584, 3, 1045, 522, 0, 1584, 1585, + 3, 1023, 511, 0, 1585, 1586, 3, 1057, 528, 0, 1586, 1587, 3, 1039, 519, + 0, 1587, 1588, 3, 1025, 512, 0, 1588, 58, 1, 0, 0, 0, 1589, 1590, 3, 1041, + 520, 0, 1590, 1591, 3, 1033, 516, 0, 1591, 1592, 3, 1021, 510, 0, 1592, + 1593, 3, 1051, 525, 0, 1593, 1594, 3, 1045, 522, 0, 1594, 1595, 3, 1027, + 513, 0, 1595, 1596, 3, 1039, 519, 0, 1596, 1597, 3, 1045, 522, 0, 1597, + 1598, 3, 1061, 530, 0, 1598, 60, 1, 0, 0, 0, 1599, 1600, 3, 1043, 521, + 0, 1600, 1601, 3, 1017, 508, 0, 1601, 1602, 3, 1043, 521, 0, 1602, 1603, + 3, 1045, 522, 0, 1603, 1604, 3, 1027, 513, 0, 1604, 1605, 3, 1039, 519, + 0, 1605, 1606, 3, 1045, 522, 0, 1606, 1607, 3, 1061, 530, 0, 1607, 62, + 1, 0, 0, 0, 1608, 1609, 3, 1061, 530, 0, 1609, 1610, 3, 1045, 522, 0, 1610, + 1611, 3, 1051, 525, 0, 1611, 1612, 3, 1037, 518, 0, 1612, 1613, 3, 1027, + 513, 0, 1613, 1614, 3, 1039, 519, 0, 1614, 1615, 3, 1045, 522, 0, 1615, + 1616, 3, 1061, 530, 0, 1616, 64, 1, 0, 0, 0, 1617, 1618, 3, 1047, 523, + 0, 1618, 1619, 3, 1017, 508, 0, 1619, 1620, 3, 1029, 514, 0, 1620, 1621, + 3, 1025, 512, 0, 1621, 66, 1, 0, 0, 0, 1622, 1623, 3, 1053, 526, 0, 1623, + 1624, 3, 1043, 521, 0, 1624, 1625, 3, 1033, 516, 0, 1625, 1626, 3, 1047, + 523, 0, 1626, 1627, 3, 1047, 523, 0, 1627, 1628, 3, 1025, 512, 0, 1628, + 1629, 3, 1055, 527, 0, 1629, 68, 1, 0, 0, 0, 1630, 1631, 3, 1039, 519, + 0, 1631, 1632, 3, 1017, 508, 0, 1632, 1633, 3, 1065, 532, 0, 1633, 1634, + 3, 1045, 522, 0, 1634, 1635, 3, 1057, 528, 0, 1635, 1636, 3, 1055, 527, + 0, 1636, 70, 1, 0, 0, 0, 1637, 1638, 3, 1043, 521, 0, 1638, 1639, 3, 1045, + 522, 0, 1639, 1640, 3, 1055, 527, 0, 1640, 1641, 3, 1025, 512, 0, 1641, + 1642, 3, 1019, 509, 0, 1642, 1643, 3, 1045, 522, 0, 1643, 1644, 3, 1045, + 522, 0, 1644, 1645, 3, 1037, 518, 0, 1645, 72, 1, 0, 0, 0, 1646, 1647, + 3, 1021, 510, 0, 1647, 1648, 3, 1045, 522, 0, 1648, 1649, 3, 1043, 521, + 0, 1649, 1650, 3, 1053, 526, 0, 1650, 1651, 3, 1055, 527, 0, 1651, 1652, + 3, 1017, 508, 0, 1652, 1653, 3, 1043, 521, 0, 1653, 1654, 3, 1055, 527, + 0, 1654, 74, 1, 0, 0, 0, 1655, 1656, 3, 1017, 508, 0, 1656, 1657, 3, 1055, + 527, 0, 1657, 1658, 3, 1055, 527, 0, 1658, 1659, 3, 1051, 525, 0, 1659, + 1660, 3, 1033, 516, 0, 1660, 1661, 3, 1019, 509, 0, 1661, 1662, 3, 1057, + 528, 0, 1662, 1663, 3, 1055, 527, 0, 1663, 1664, 3, 1025, 512, 0, 1664, + 76, 1, 0, 0, 0, 1665, 1666, 3, 1021, 510, 0, 1666, 1667, 3, 1045, 522, + 0, 1667, 1668, 3, 1039, 519, 0, 1668, 1669, 3, 1057, 528, 0, 1669, 1670, + 3, 1041, 520, 0, 1670, 1671, 3, 1043, 521, 0, 1671, 78, 1, 0, 0, 0, 1672, + 1673, 3, 1021, 510, 0, 1673, 1674, 3, 1045, 522, 0, 1674, 1675, 3, 1039, + 519, 0, 1675, 1676, 3, 1057, 528, 0, 1676, 1677, 3, 1041, 520, 0, 1677, + 1678, 3, 1043, 521, 0, 1678, 1679, 3, 1053, 526, 0, 1679, 80, 1, 0, 0, + 0, 1680, 1681, 3, 1033, 516, 0, 1681, 1682, 3, 1043, 521, 0, 1682, 1683, + 3, 1023, 511, 0, 1683, 1684, 3, 1025, 512, 0, 1684, 1685, 3, 1063, 531, + 0, 1685, 82, 1, 0, 0, 0, 1686, 1687, 3, 1045, 522, 0, 1687, 1688, 3, 1061, + 530, 0, 1688, 1689, 3, 1043, 521, 0, 1689, 1690, 3, 1025, 512, 0, 1690, + 1691, 3, 1051, 525, 0, 1691, 84, 1, 0, 0, 0, 1692, 1693, 3, 1051, 525, + 0, 1693, 1694, 3, 1025, 512, 0, 1694, 1695, 3, 1027, 513, 0, 1695, 1696, + 3, 1025, 512, 0, 1696, 1697, 3, 1051, 525, 0, 1697, 1698, 3, 1025, 512, + 0, 1698, 1699, 3, 1043, 521, 0, 1699, 1700, 3, 1021, 510, 0, 1700, 1701, + 3, 1025, 512, 0, 1701, 86, 1, 0, 0, 0, 1702, 1703, 3, 1029, 514, 0, 1703, + 1704, 3, 1025, 512, 0, 1704, 1705, 3, 1043, 521, 0, 1705, 1706, 3, 1025, + 512, 0, 1706, 1707, 3, 1051, 525, 0, 1707, 1708, 3, 1017, 508, 0, 1708, + 1709, 3, 1039, 519, 0, 1709, 1710, 3, 1033, 516, 0, 1710, 1711, 3, 1067, + 533, 0, 1711, 1712, 3, 1017, 508, 0, 1712, 1713, 3, 1055, 527, 0, 1713, + 1714, 3, 1033, 516, 0, 1714, 1715, 3, 1045, 522, 0, 1715, 1716, 3, 1043, + 521, 0, 1716, 88, 1, 0, 0, 0, 1717, 1718, 3, 1025, 512, 0, 1718, 1719, + 3, 1063, 531, 0, 1719, 1720, 3, 1055, 527, 0, 1720, 1721, 3, 1025, 512, + 0, 1721, 1722, 3, 1043, 521, 0, 1722, 1723, 3, 1023, 511, 0, 1723, 1724, + 3, 1053, 526, 0, 1724, 90, 1, 0, 0, 0, 1725, 1726, 3, 1017, 508, 0, 1726, + 1727, 3, 1023, 511, 0, 1727, 1728, 3, 1023, 511, 0, 1728, 92, 1, 0, 0, + 0, 1729, 1730, 3, 1053, 526, 0, 1730, 1731, 3, 1025, 512, 0, 1731, 1732, + 3, 1055, 527, 0, 1732, 94, 1, 0, 0, 0, 1733, 1734, 3, 1047, 523, 0, 1734, + 1735, 3, 1045, 522, 0, 1735, 1736, 3, 1053, 526, 0, 1736, 1737, 3, 1033, + 516, 0, 1737, 1738, 3, 1055, 527, 0, 1738, 1739, 3, 1033, 516, 0, 1739, + 1740, 3, 1045, 522, 0, 1740, 1741, 3, 1043, 521, 0, 1741, 96, 1, 0, 0, + 0, 1742, 1743, 3, 1023, 511, 0, 1743, 1744, 3, 1045, 522, 0, 1744, 1745, + 3, 1021, 510, 0, 1745, 1746, 3, 1057, 528, 0, 1746, 1747, 3, 1041, 520, + 0, 1747, 1748, 3, 1025, 512, 0, 1748, 1749, 3, 1043, 521, 0, 1749, 1750, + 3, 1055, 527, 0, 1750, 1751, 3, 1017, 508, 0, 1751, 1752, 3, 1055, 527, + 0, 1752, 1753, 3, 1033, 516, 0, 1753, 1754, 3, 1045, 522, 0, 1754, 1755, + 3, 1043, 521, 0, 1755, 98, 1, 0, 0, 0, 1756, 1757, 3, 1053, 526, 0, 1757, + 1758, 3, 1055, 527, 0, 1758, 1759, 3, 1045, 522, 0, 1759, 1760, 3, 1051, + 525, 0, 1760, 1761, 3, 1017, 508, 0, 1761, 1762, 3, 1029, 514, 0, 1762, + 1763, 3, 1025, 512, 0, 1763, 100, 1, 0, 0, 0, 1764, 1765, 3, 1055, 527, + 0, 1765, 1766, 3, 1017, 508, 0, 1766, 1767, 3, 1019, 509, 0, 1767, 1768, + 3, 1039, 519, 0, 1768, 1769, 3, 1025, 512, 0, 1769, 102, 1, 0, 0, 0, 1770, + 1771, 3, 1023, 511, 0, 1771, 1772, 3, 1025, 512, 0, 1772, 1773, 3, 1039, + 519, 0, 1773, 1774, 3, 1025, 512, 0, 1774, 1775, 3, 1055, 527, 0, 1775, + 1777, 3, 1025, 512, 0, 1776, 1778, 5, 95, 0, 0, 1777, 1776, 1, 0, 0, 0, + 1777, 1778, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1780, 3, 1019, 509, + 0, 1780, 1781, 3, 1025, 512, 0, 1781, 1782, 3, 1031, 515, 0, 1782, 1783, + 3, 1017, 508, 0, 1783, 1784, 3, 1059, 529, 0, 1784, 1785, 3, 1033, 516, + 0, 1785, 1786, 3, 1045, 522, 0, 1786, 1787, 3, 1051, 525, 0, 1787, 104, + 1, 0, 0, 0, 1788, 1789, 3, 1021, 510, 0, 1789, 1790, 3, 1017, 508, 0, 1790, + 1791, 3, 1053, 526, 0, 1791, 1792, 3, 1021, 510, 0, 1792, 1793, 3, 1017, + 508, 0, 1793, 1794, 3, 1023, 511, 0, 1794, 1795, 3, 1025, 512, 0, 1795, + 106, 1, 0, 0, 0, 1796, 1797, 3, 1047, 523, 0, 1797, 1798, 3, 1051, 525, + 0, 1798, 1799, 3, 1025, 512, 0, 1799, 1800, 3, 1059, 529, 0, 1800, 1801, + 3, 1025, 512, 0, 1801, 1802, 3, 1043, 521, 0, 1802, 1803, 3, 1055, 527, + 0, 1803, 108, 1, 0, 0, 0, 1804, 1805, 3, 1021, 510, 0, 1805, 1806, 3, 1045, + 522, 0, 1806, 1807, 3, 1043, 521, 0, 1807, 1808, 3, 1043, 521, 0, 1808, + 1809, 3, 1025, 512, 0, 1809, 1810, 3, 1021, 510, 0, 1810, 1811, 3, 1055, + 527, 0, 1811, 110, 1, 0, 0, 0, 1812, 1813, 3, 1023, 511, 0, 1813, 1814, + 3, 1033, 516, 0, 1814, 1815, 3, 1053, 526, 0, 1815, 1816, 3, 1021, 510, + 0, 1816, 1817, 3, 1045, 522, 0, 1817, 1818, 3, 1043, 521, 0, 1818, 1819, + 3, 1043, 521, 0, 1819, 1820, 3, 1025, 512, 0, 1820, 1821, 3, 1021, 510, + 0, 1821, 1822, 3, 1055, 527, 0, 1822, 112, 1, 0, 0, 0, 1823, 1824, 3, 1039, + 519, 0, 1824, 1825, 3, 1045, 522, 0, 1825, 1826, 3, 1021, 510, 0, 1826, + 1827, 3, 1017, 508, 0, 1827, 1828, 3, 1039, 519, 0, 1828, 114, 1, 0, 0, + 0, 1829, 1830, 3, 1047, 523, 0, 1830, 1831, 3, 1051, 525, 0, 1831, 1832, + 3, 1045, 522, 0, 1832, 1833, 3, 1035, 517, 0, 1833, 1834, 3, 1025, 512, + 0, 1834, 1835, 3, 1021, 510, 0, 1835, 1836, 3, 1055, 527, 0, 1836, 116, + 1, 0, 0, 0, 1837, 1838, 3, 1051, 525, 0, 1838, 1839, 3, 1057, 528, 0, 1839, + 1840, 3, 1043, 521, 0, 1840, 1841, 3, 1055, 527, 0, 1841, 1842, 3, 1033, + 516, 0, 1842, 1843, 3, 1041, 520, 0, 1843, 1844, 3, 1025, 512, 0, 1844, + 118, 1, 0, 0, 0, 1845, 1846, 3, 1019, 509, 0, 1846, 1847, 3, 1051, 525, + 0, 1847, 1848, 3, 1017, 508, 0, 1848, 1849, 3, 1043, 521, 0, 1849, 1850, + 3, 1021, 510, 0, 1850, 1851, 3, 1031, 515, 0, 1851, 120, 1, 0, 0, 0, 1852, + 1853, 3, 1055, 527, 0, 1853, 1854, 3, 1045, 522, 0, 1854, 1855, 3, 1037, + 518, 0, 1855, 1856, 3, 1025, 512, 0, 1856, 1857, 3, 1043, 521, 0, 1857, + 122, 1, 0, 0, 0, 1858, 1859, 3, 1031, 515, 0, 1859, 1860, 3, 1045, 522, + 0, 1860, 1861, 3, 1053, 526, 0, 1861, 1862, 3, 1055, 527, 0, 1862, 124, + 1, 0, 0, 0, 1863, 1864, 3, 1047, 523, 0, 1864, 1865, 3, 1045, 522, 0, 1865, + 1866, 3, 1051, 525, 0, 1866, 1867, 3, 1055, 527, 0, 1867, 126, 1, 0, 0, + 0, 1868, 1869, 3, 1053, 526, 0, 1869, 1870, 3, 1031, 515, 0, 1870, 1871, + 3, 1045, 522, 0, 1871, 1872, 3, 1061, 530, 0, 1872, 128, 1, 0, 0, 0, 1873, + 1874, 3, 1023, 511, 0, 1874, 1875, 3, 1025, 512, 0, 1875, 1876, 3, 1053, + 526, 0, 1876, 1877, 3, 1021, 510, 0, 1877, 1878, 3, 1051, 525, 0, 1878, + 1879, 3, 1033, 516, 0, 1879, 1880, 3, 1019, 509, 0, 1880, 1881, 3, 1025, + 512, 0, 1881, 130, 1, 0, 0, 0, 1882, 1883, 3, 1057, 528, 0, 1883, 1884, + 3, 1053, 526, 0, 1884, 1885, 3, 1025, 512, 0, 1885, 132, 1, 0, 0, 0, 1886, + 1887, 3, 1033, 516, 0, 1887, 1888, 3, 1043, 521, 0, 1888, 1889, 3, 1055, + 527, 0, 1889, 1890, 3, 1051, 525, 0, 1890, 1891, 3, 1045, 522, 0, 1891, + 1892, 3, 1053, 526, 0, 1892, 1893, 3, 1047, 523, 0, 1893, 1894, 3, 1025, + 512, 0, 1894, 1895, 3, 1021, 510, 0, 1895, 1896, 3, 1055, 527, 0, 1896, + 134, 1, 0, 0, 0, 1897, 1898, 3, 1023, 511, 0, 1898, 1899, 3, 1025, 512, + 0, 1899, 1900, 3, 1019, 509, 0, 1900, 1901, 3, 1057, 528, 0, 1901, 1902, + 3, 1029, 514, 0, 1902, 136, 1, 0, 0, 0, 1903, 1904, 3, 1053, 526, 0, 1904, + 1905, 3, 1025, 512, 0, 1905, 1906, 3, 1039, 519, 0, 1906, 1907, 3, 1025, + 512, 0, 1907, 1908, 3, 1021, 510, 0, 1908, 1909, 3, 1055, 527, 0, 1909, + 138, 1, 0, 0, 0, 1910, 1911, 3, 1027, 513, 0, 1911, 1912, 3, 1051, 525, + 0, 1912, 1913, 3, 1045, 522, 0, 1913, 1914, 3, 1041, 520, 0, 1914, 140, + 1, 0, 0, 0, 1915, 1916, 3, 1061, 530, 0, 1916, 1917, 3, 1031, 515, 0, 1917, + 1918, 3, 1025, 512, 0, 1918, 1919, 3, 1051, 525, 0, 1919, 1920, 3, 1025, + 512, 0, 1920, 142, 1, 0, 0, 0, 1921, 1922, 3, 1031, 515, 0, 1922, 1923, + 3, 1017, 508, 0, 1923, 1924, 3, 1059, 529, 0, 1924, 1925, 3, 1033, 516, + 0, 1925, 1926, 3, 1043, 521, 0, 1926, 1927, 3, 1029, 514, 0, 1927, 144, + 1, 0, 0, 0, 1928, 1929, 3, 1045, 522, 0, 1929, 1930, 3, 1027, 513, 0, 1930, + 1931, 3, 1027, 513, 0, 1931, 1932, 3, 1053, 526, 0, 1932, 1933, 3, 1025, + 512, 0, 1933, 1934, 3, 1055, 527, 0, 1934, 146, 1, 0, 0, 0, 1935, 1936, + 3, 1039, 519, 0, 1936, 1937, 3, 1033, 516, 0, 1937, 1938, 3, 1041, 520, + 0, 1938, 1939, 3, 1033, 516, 0, 1939, 1940, 3, 1055, 527, 0, 1940, 148, + 1, 0, 0, 0, 1941, 1942, 3, 1017, 508, 0, 1942, 1943, 3, 1053, 526, 0, 1943, + 150, 1, 0, 0, 0, 1944, 1945, 3, 1051, 525, 0, 1945, 1946, 3, 1025, 512, + 0, 1946, 1947, 3, 1055, 527, 0, 1947, 1948, 3, 1057, 528, 0, 1948, 1949, + 3, 1051, 525, 0, 1949, 1950, 3, 1043, 521, 0, 1950, 1951, 3, 1053, 526, + 0, 1951, 152, 1, 0, 0, 0, 1952, 1953, 3, 1051, 525, 0, 1953, 1954, 3, 1025, + 512, 0, 1954, 1955, 3, 1055, 527, 0, 1955, 1956, 3, 1057, 528, 0, 1956, + 1957, 3, 1051, 525, 0, 1957, 1958, 3, 1043, 521, 0, 1958, 1959, 3, 1033, + 516, 0, 1959, 1960, 3, 1043, 521, 0, 1960, 1961, 3, 1029, 514, 0, 1961, + 154, 1, 0, 0, 0, 1962, 1963, 3, 1021, 510, 0, 1963, 1964, 3, 1017, 508, + 0, 1964, 1965, 3, 1053, 526, 0, 1965, 1966, 3, 1025, 512, 0, 1966, 156, + 1, 0, 0, 0, 1967, 1968, 3, 1061, 530, 0, 1968, 1969, 3, 1031, 515, 0, 1969, + 1970, 3, 1025, 512, 0, 1970, 1971, 3, 1043, 521, 0, 1971, 158, 1, 0, 0, + 0, 1972, 1973, 3, 1055, 527, 0, 1973, 1974, 3, 1031, 515, 0, 1974, 1975, + 3, 1025, 512, 0, 1975, 1976, 3, 1043, 521, 0, 1976, 160, 1, 0, 0, 0, 1977, + 1978, 3, 1025, 512, 0, 1978, 1979, 3, 1039, 519, 0, 1979, 1980, 3, 1053, + 526, 0, 1980, 1981, 3, 1025, 512, 0, 1981, 162, 1, 0, 0, 0, 1982, 1983, + 3, 1025, 512, 0, 1983, 1984, 3, 1043, 521, 0, 1984, 1985, 3, 1023, 511, + 0, 1985, 164, 1, 0, 0, 0, 1986, 1987, 3, 1023, 511, 0, 1987, 1988, 3, 1033, + 516, 0, 1988, 1989, 3, 1053, 526, 0, 1989, 1990, 3, 1055, 527, 0, 1990, + 1991, 3, 1033, 516, 0, 1991, 1992, 3, 1043, 521, 0, 1992, 1993, 3, 1021, + 510, 0, 1993, 1994, 3, 1055, 527, 0, 1994, 166, 1, 0, 0, 0, 1995, 1996, + 3, 1017, 508, 0, 1996, 1997, 3, 1039, 519, 0, 1997, 1998, 3, 1039, 519, + 0, 1998, 168, 1, 0, 0, 0, 1999, 2000, 3, 1035, 517, 0, 2000, 2001, 3, 1045, + 522, 0, 2001, 2002, 3, 1033, 516, 0, 2002, 2003, 3, 1043, 521, 0, 2003, + 170, 1, 0, 0, 0, 2004, 2005, 3, 1039, 519, 0, 2005, 2006, 3, 1025, 512, + 0, 2006, 2007, 3, 1027, 513, 0, 2007, 2008, 3, 1055, 527, 0, 2008, 172, + 1, 0, 0, 0, 2009, 2010, 3, 1051, 525, 0, 2010, 2011, 3, 1033, 516, 0, 2011, + 2012, 3, 1029, 514, 0, 2012, 2013, 3, 1031, 515, 0, 2013, 2014, 3, 1055, + 527, 0, 2014, 174, 1, 0, 0, 0, 2015, 2016, 3, 1033, 516, 0, 2016, 2017, + 3, 1043, 521, 0, 2017, 2018, 3, 1043, 521, 0, 2018, 2019, 3, 1025, 512, + 0, 2019, 2020, 3, 1051, 525, 0, 2020, 176, 1, 0, 0, 0, 2021, 2022, 3, 1045, + 522, 0, 2022, 2023, 3, 1057, 528, 0, 2023, 2024, 3, 1055, 527, 0, 2024, + 2025, 3, 1025, 512, 0, 2025, 2026, 3, 1051, 525, 0, 2026, 178, 1, 0, 0, + 0, 2027, 2028, 3, 1027, 513, 0, 2028, 2029, 3, 1057, 528, 0, 2029, 2030, + 3, 1039, 519, 0, 2030, 2031, 3, 1039, 519, 0, 2031, 180, 1, 0, 0, 0, 2032, + 2033, 3, 1021, 510, 0, 2033, 2034, 3, 1051, 525, 0, 2034, 2035, 3, 1045, + 522, 0, 2035, 2036, 3, 1053, 526, 0, 2036, 2037, 3, 1053, 526, 0, 2037, + 182, 1, 0, 0, 0, 2038, 2039, 3, 1045, 522, 0, 2039, 2040, 3, 1043, 521, + 0, 2040, 184, 1, 0, 0, 0, 2041, 2042, 3, 1017, 508, 0, 2042, 2043, 3, 1053, + 526, 0, 2043, 2044, 3, 1021, 510, 0, 2044, 186, 1, 0, 0, 0, 2045, 2046, + 3, 1023, 511, 0, 2046, 2047, 3, 1025, 512, 0, 2047, 2048, 3, 1053, 526, + 0, 2048, 2049, 3, 1021, 510, 0, 2049, 188, 1, 0, 0, 0, 2050, 2051, 3, 1019, + 509, 0, 2051, 2052, 3, 1025, 512, 0, 2052, 2053, 3, 1029, 514, 0, 2053, + 2054, 3, 1033, 516, 0, 2054, 2055, 3, 1043, 521, 0, 2055, 190, 1, 0, 0, + 0, 2056, 2057, 3, 1023, 511, 0, 2057, 2058, 3, 1025, 512, 0, 2058, 2059, + 3, 1021, 510, 0, 2059, 2060, 3, 1039, 519, 0, 2060, 2061, 3, 1017, 508, + 0, 2061, 2062, 3, 1051, 525, 0, 2062, 2063, 3, 1025, 512, 0, 2063, 192, + 1, 0, 0, 0, 2064, 2065, 3, 1021, 510, 0, 2065, 2066, 3, 1031, 515, 0, 2066, + 2067, 3, 1017, 508, 0, 2067, 2068, 3, 1043, 521, 0, 2068, 2069, 3, 1029, + 514, 0, 2069, 2070, 3, 1025, 512, 0, 2070, 194, 1, 0, 0, 0, 2071, 2072, + 3, 1051, 525, 0, 2072, 2073, 3, 1025, 512, 0, 2073, 2074, 3, 1055, 527, + 0, 2074, 2075, 3, 1051, 525, 0, 2075, 2076, 3, 1033, 516, 0, 2076, 2077, + 3, 1025, 512, 0, 2077, 2078, 3, 1059, 529, 0, 2078, 2079, 3, 1025, 512, + 0, 2079, 196, 1, 0, 0, 0, 2080, 2081, 3, 1023, 511, 0, 2081, 2082, 3, 1025, + 512, 0, 2082, 2083, 3, 1039, 519, 0, 2083, 2084, 3, 1025, 512, 0, 2084, + 2085, 3, 1055, 527, 0, 2085, 2086, 3, 1025, 512, 0, 2086, 198, 1, 0, 0, + 0, 2087, 2088, 3, 1021, 510, 0, 2088, 2089, 3, 1045, 522, 0, 2089, 2090, + 3, 1041, 520, 0, 2090, 2091, 3, 1041, 520, 0, 2091, 2092, 3, 1033, 516, + 0, 2092, 2093, 3, 1055, 527, 0, 2093, 200, 1, 0, 0, 0, 2094, 2095, 3, 1051, + 525, 0, 2095, 2096, 3, 1045, 522, 0, 2096, 2097, 3, 1039, 519, 0, 2097, + 2098, 3, 1039, 519, 0, 2098, 2099, 3, 1019, 509, 0, 2099, 2100, 3, 1017, + 508, 0, 2100, 2101, 3, 1021, 510, 0, 2101, 2102, 3, 1037, 518, 0, 2102, + 202, 1, 0, 0, 0, 2103, 2104, 3, 1039, 519, 0, 2104, 2105, 3, 1045, 522, + 0, 2105, 2106, 3, 1045, 522, 0, 2106, 2107, 3, 1047, 523, 0, 2107, 204, + 1, 0, 0, 0, 2108, 2109, 3, 1061, 530, 0, 2109, 2110, 3, 1031, 515, 0, 2110, + 2111, 3, 1033, 516, 0, 2111, 2112, 3, 1039, 519, 0, 2112, 2113, 3, 1025, + 512, 0, 2113, 206, 1, 0, 0, 0, 2114, 2115, 3, 1033, 516, 0, 2115, 2116, + 3, 1027, 513, 0, 2116, 208, 1, 0, 0, 0, 2117, 2118, 3, 1025, 512, 0, 2118, + 2119, 3, 1039, 519, 0, 2119, 2120, 3, 1053, 526, 0, 2120, 2121, 3, 1033, + 516, 0, 2121, 2122, 3, 1027, 513, 0, 2122, 210, 1, 0, 0, 0, 2123, 2124, + 3, 1025, 512, 0, 2124, 2125, 3, 1039, 519, 0, 2125, 2126, 3, 1053, 526, + 0, 2126, 2127, 3, 1025, 512, 0, 2127, 2128, 3, 1033, 516, 0, 2128, 2129, + 3, 1027, 513, 0, 2129, 212, 1, 0, 0, 0, 2130, 2131, 3, 1021, 510, 0, 2131, + 2132, 3, 1045, 522, 0, 2132, 2133, 3, 1043, 521, 0, 2133, 2134, 3, 1055, + 527, 0, 2134, 2135, 3, 1033, 516, 0, 2135, 2136, 3, 1043, 521, 0, 2136, + 2137, 3, 1057, 528, 0, 2137, 2138, 3, 1025, 512, 0, 2138, 214, 1, 0, 0, + 0, 2139, 2140, 3, 1019, 509, 0, 2140, 2141, 3, 1051, 525, 0, 2141, 2142, + 3, 1025, 512, 0, 2142, 2143, 3, 1017, 508, 0, 2143, 2144, 3, 1037, 518, + 0, 2144, 216, 1, 0, 0, 0, 2145, 2146, 3, 1051, 525, 0, 2146, 2147, 3, 1025, + 512, 0, 2147, 2148, 3, 1055, 527, 0, 2148, 2149, 3, 1057, 528, 0, 2149, + 2150, 3, 1051, 525, 0, 2150, 2151, 3, 1043, 521, 0, 2151, 218, 1, 0, 0, + 0, 2152, 2153, 3, 1055, 527, 0, 2153, 2154, 3, 1031, 515, 0, 2154, 2155, + 3, 1051, 525, 0, 2155, 2156, 3, 1045, 522, 0, 2156, 2157, 3, 1061, 530, + 0, 2157, 220, 1, 0, 0, 0, 2158, 2159, 3, 1039, 519, 0, 2159, 2160, 3, 1045, + 522, 0, 2160, 2161, 3, 1029, 514, 0, 2161, 222, 1, 0, 0, 0, 2162, 2163, + 3, 1021, 510, 0, 2163, 2164, 3, 1017, 508, 0, 2164, 2165, 3, 1039, 519, + 0, 2165, 2166, 3, 1039, 519, 0, 2166, 224, 1, 0, 0, 0, 2167, 2168, 3, 1035, + 517, 0, 2168, 2169, 3, 1017, 508, 0, 2169, 2170, 3, 1059, 529, 0, 2170, + 2171, 3, 1017, 508, 0, 2171, 226, 1, 0, 0, 0, 2172, 2173, 3, 1017, 508, + 0, 2173, 2174, 3, 1021, 510, 0, 2174, 2175, 3, 1055, 527, 0, 2175, 2176, + 3, 1033, 516, 0, 2176, 2177, 3, 1045, 522, 0, 2177, 2178, 3, 1043, 521, + 0, 2178, 228, 1, 0, 0, 0, 2179, 2180, 3, 1017, 508, 0, 2180, 2181, 3, 1021, + 510, 0, 2181, 2182, 3, 1055, 527, 0, 2182, 2183, 3, 1033, 516, 0, 2183, + 2184, 3, 1045, 522, 0, 2184, 2185, 3, 1043, 521, 0, 2185, 2186, 3, 1053, + 526, 0, 2186, 230, 1, 0, 0, 0, 2187, 2188, 3, 1021, 510, 0, 2188, 2189, + 3, 1039, 519, 0, 2189, 2190, 3, 1045, 522, 0, 2190, 2191, 3, 1053, 526, + 0, 2191, 2192, 3, 1025, 512, 0, 2192, 232, 1, 0, 0, 0, 2193, 2194, 3, 1043, + 521, 0, 2194, 2195, 3, 1045, 522, 0, 2195, 2196, 3, 1023, 511, 0, 2196, + 2197, 3, 1025, 512, 0, 2197, 234, 1, 0, 0, 0, 2198, 2199, 3, 1025, 512, + 0, 2199, 2200, 3, 1059, 529, 0, 2200, 2201, 3, 1025, 512, 0, 2201, 2202, + 3, 1043, 521, 0, 2202, 2203, 3, 1055, 527, 0, 2203, 2204, 3, 1053, 526, + 0, 2204, 236, 1, 0, 0, 0, 2205, 2206, 3, 1031, 515, 0, 2206, 2207, 3, 1025, + 512, 0, 2207, 2208, 3, 1017, 508, 0, 2208, 2209, 3, 1023, 511, 0, 2209, + 238, 1, 0, 0, 0, 2210, 2211, 3, 1055, 527, 0, 2211, 2212, 3, 1017, 508, + 0, 2212, 2213, 3, 1033, 516, 0, 2213, 2214, 3, 1039, 519, 0, 2214, 240, + 1, 0, 0, 0, 2215, 2216, 3, 1027, 513, 0, 2216, 2217, 3, 1033, 516, 0, 2217, + 2218, 3, 1043, 521, 0, 2218, 2219, 3, 1023, 511, 0, 2219, 242, 1, 0, 0, + 0, 2220, 2221, 3, 1053, 526, 0, 2221, 2222, 3, 1045, 522, 0, 2222, 2223, + 3, 1051, 525, 0, 2223, 2224, 3, 1055, 527, 0, 2224, 244, 1, 0, 0, 0, 2225, + 2226, 3, 1057, 528, 0, 2226, 2227, 3, 1043, 521, 0, 2227, 2228, 3, 1033, + 516, 0, 2228, 2229, 3, 1045, 522, 0, 2229, 2230, 3, 1043, 521, 0, 2230, + 246, 1, 0, 0, 0, 2231, 2232, 3, 1033, 516, 0, 2232, 2233, 3, 1043, 521, + 0, 2233, 2234, 3, 1055, 527, 0, 2234, 2235, 3, 1025, 512, 0, 2235, 2236, + 3, 1051, 525, 0, 2236, 2237, 3, 1053, 526, 0, 2237, 2238, 3, 1025, 512, + 0, 2238, 2239, 3, 1021, 510, 0, 2239, 2240, 3, 1055, 527, 0, 2240, 248, + 1, 0, 0, 0, 2241, 2242, 3, 1053, 526, 0, 2242, 2243, 3, 1057, 528, 0, 2243, + 2244, 3, 1019, 509, 0, 2244, 2245, 3, 1055, 527, 0, 2245, 2246, 3, 1051, + 525, 0, 2246, 2247, 3, 1017, 508, 0, 2247, 2248, 3, 1021, 510, 0, 2248, + 2249, 3, 1055, 527, 0, 2249, 250, 1, 0, 0, 0, 2250, 2251, 3, 1021, 510, + 0, 2251, 2252, 3, 1045, 522, 0, 2252, 2253, 3, 1043, 521, 0, 2253, 2254, + 3, 1055, 527, 0, 2254, 2255, 3, 1017, 508, 0, 2255, 2256, 3, 1033, 516, + 0, 2256, 2257, 3, 1043, 521, 0, 2257, 2258, 3, 1053, 526, 0, 2258, 252, + 1, 0, 0, 0, 2259, 2260, 3, 1017, 508, 0, 2260, 2261, 3, 1059, 529, 0, 2261, + 2262, 3, 1025, 512, 0, 2262, 2263, 3, 1051, 525, 0, 2263, 2264, 3, 1017, + 508, 0, 2264, 2265, 3, 1029, 514, 0, 2265, 2266, 3, 1025, 512, 0, 2266, + 254, 1, 0, 0, 0, 2267, 2268, 3, 1041, 520, 0, 2268, 2269, 3, 1033, 516, + 0, 2269, 2270, 3, 1043, 521, 0, 2270, 2271, 3, 1033, 516, 0, 2271, 2272, + 3, 1041, 520, 0, 2272, 2273, 3, 1057, 528, 0, 2273, 2274, 3, 1041, 520, + 0, 2274, 256, 1, 0, 0, 0, 2275, 2276, 3, 1041, 520, 0, 2276, 2277, 3, 1017, + 508, 0, 2277, 2278, 3, 1063, 531, 0, 2278, 2279, 3, 1033, 516, 0, 2279, + 2280, 3, 1041, 520, 0, 2280, 2281, 3, 1057, 528, 0, 2281, 2282, 3, 1041, + 520, 0, 2282, 258, 1, 0, 0, 0, 2283, 2284, 3, 1039, 519, 0, 2284, 2285, + 3, 1033, 516, 0, 2285, 2286, 3, 1053, 526, 0, 2286, 2287, 3, 1055, 527, + 0, 2287, 260, 1, 0, 0, 0, 2288, 2289, 3, 1051, 525, 0, 2289, 2290, 3, 1025, + 512, 0, 2290, 2291, 3, 1041, 520, 0, 2291, 2292, 3, 1045, 522, 0, 2292, + 2293, 3, 1059, 529, 0, 2293, 2294, 3, 1025, 512, 0, 2294, 262, 1, 0, 0, + 0, 2295, 2296, 3, 1025, 512, 0, 2296, 2297, 3, 1049, 524, 0, 2297, 2298, + 3, 1057, 528, 0, 2298, 2299, 3, 1017, 508, 0, 2299, 2300, 3, 1039, 519, + 0, 2300, 2301, 3, 1053, 526, 0, 2301, 264, 1, 0, 0, 0, 2302, 2303, 3, 1033, + 516, 0, 2303, 2304, 3, 1043, 521, 0, 2304, 2305, 3, 1027, 513, 0, 2305, + 2306, 3, 1045, 522, 0, 2306, 266, 1, 0, 0, 0, 2307, 2308, 3, 1061, 530, + 0, 2308, 2309, 3, 1017, 508, 0, 2309, 2310, 3, 1051, 525, 0, 2310, 2311, + 3, 1043, 521, 0, 2311, 2312, 3, 1033, 516, 0, 2312, 2313, 3, 1043, 521, + 0, 2313, 2314, 3, 1029, 514, 0, 2314, 268, 1, 0, 0, 0, 2315, 2316, 3, 1055, + 527, 0, 2316, 2317, 3, 1051, 525, 0, 2317, 2318, 3, 1017, 508, 0, 2318, + 2319, 3, 1021, 510, 0, 2319, 2320, 3, 1025, 512, 0, 2320, 270, 1, 0, 0, + 0, 2321, 2322, 3, 1021, 510, 0, 2322, 2323, 3, 1051, 525, 0, 2323, 2324, + 3, 1033, 516, 0, 2324, 2325, 3, 1055, 527, 0, 2325, 2326, 3, 1033, 516, + 0, 2326, 2327, 3, 1021, 510, 0, 2327, 2328, 3, 1017, 508, 0, 2328, 2329, + 3, 1039, 519, 0, 2329, 272, 1, 0, 0, 0, 2330, 2331, 3, 1061, 530, 0, 2331, + 2332, 3, 1033, 516, 0, 2332, 2333, 3, 1055, 527, 0, 2333, 2334, 3, 1031, + 515, 0, 2334, 274, 1, 0, 0, 0, 2335, 2336, 3, 1025, 512, 0, 2336, 2337, + 3, 1041, 520, 0, 2337, 2338, 3, 1047, 523, 0, 2338, 2339, 3, 1055, 527, + 0, 2339, 2340, 3, 1065, 532, 0, 2340, 276, 1, 0, 0, 0, 2341, 2342, 3, 1045, + 522, 0, 2342, 2343, 3, 1019, 509, 0, 2343, 2344, 3, 1035, 517, 0, 2344, + 2345, 3, 1025, 512, 0, 2345, 2346, 3, 1021, 510, 0, 2346, 2347, 3, 1055, + 527, 0, 2347, 278, 1, 0, 0, 0, 2348, 2349, 3, 1045, 522, 0, 2349, 2350, + 3, 1019, 509, 0, 2350, 2351, 3, 1035, 517, 0, 2351, 2352, 3, 1025, 512, + 0, 2352, 2353, 3, 1021, 510, 0, 2353, 2354, 3, 1055, 527, 0, 2354, 2355, + 3, 1053, 526, 0, 2355, 280, 1, 0, 0, 0, 2356, 2357, 3, 1047, 523, 0, 2357, + 2358, 3, 1017, 508, 0, 2358, 2359, 3, 1029, 514, 0, 2359, 2360, 3, 1025, + 512, 0, 2360, 2361, 3, 1053, 526, 0, 2361, 282, 1, 0, 0, 0, 2362, 2363, + 3, 1039, 519, 0, 2363, 2364, 3, 1017, 508, 0, 2364, 2365, 3, 1065, 532, + 0, 2365, 2366, 3, 1045, 522, 0, 2366, 2367, 3, 1057, 528, 0, 2367, 2368, + 3, 1055, 527, 0, 2368, 2369, 3, 1053, 526, 0, 2369, 284, 1, 0, 0, 0, 2370, + 2371, 3, 1053, 526, 0, 2371, 2372, 3, 1043, 521, 0, 2372, 2373, 3, 1033, + 516, 0, 2373, 2374, 3, 1047, 523, 0, 2374, 2375, 3, 1047, 523, 0, 2375, + 2376, 3, 1025, 512, 0, 2376, 2377, 3, 1055, 527, 0, 2377, 2378, 3, 1053, + 526, 0, 2378, 286, 1, 0, 0, 0, 2379, 2380, 3, 1043, 521, 0, 2380, 2381, + 3, 1045, 522, 0, 2381, 2382, 3, 1055, 527, 0, 2382, 2383, 3, 1025, 512, + 0, 2383, 2384, 3, 1019, 509, 0, 2384, 2385, 3, 1045, 522, 0, 2385, 2386, + 3, 1045, 522, 0, 2386, 2387, 3, 1037, 518, 0, 2387, 2388, 3, 1053, 526, + 0, 2388, 288, 1, 0, 0, 0, 2389, 2390, 3, 1047, 523, 0, 2390, 2391, 3, 1039, + 519, 0, 2391, 2392, 3, 1017, 508, 0, 2392, 2393, 3, 1021, 510, 0, 2393, + 2394, 3, 1025, 512, 0, 2394, 2395, 3, 1031, 515, 0, 2395, 2396, 3, 1045, + 522, 0, 2396, 2397, 3, 1039, 519, 0, 2397, 2398, 3, 1023, 511, 0, 2398, + 2399, 3, 1025, 512, 0, 2399, 2400, 3, 1051, 525, 0, 2400, 290, 1, 0, 0, + 0, 2401, 2402, 3, 1053, 526, 0, 2402, 2403, 3, 1043, 521, 0, 2403, 2404, + 3, 1033, 516, 0, 2404, 2405, 3, 1047, 523, 0, 2405, 2406, 3, 1047, 523, + 0, 2406, 2407, 3, 1025, 512, 0, 2407, 2408, 3, 1055, 527, 0, 2408, 2409, + 3, 1021, 510, 0, 2409, 2410, 3, 1017, 508, 0, 2410, 2411, 3, 1039, 519, + 0, 2411, 2412, 3, 1039, 519, 0, 2412, 292, 1, 0, 0, 0, 2413, 2414, 3, 1039, + 519, 0, 2414, 2415, 3, 1017, 508, 0, 2415, 2416, 3, 1065, 532, 0, 2416, + 2417, 3, 1045, 522, 0, 2417, 2418, 3, 1057, 528, 0, 2418, 2419, 3, 1055, + 527, 0, 2419, 2420, 3, 1029, 514, 0, 2420, 2421, 3, 1051, 525, 0, 2421, + 2422, 3, 1033, 516, 0, 2422, 2423, 3, 1023, 511, 0, 2423, 294, 1, 0, 0, + 0, 2424, 2425, 3, 1023, 511, 0, 2425, 2426, 3, 1017, 508, 0, 2426, 2427, + 3, 1055, 527, 0, 2427, 2428, 3, 1017, 508, 0, 2428, 2429, 3, 1029, 514, + 0, 2429, 2430, 3, 1051, 525, 0, 2430, 2431, 3, 1033, 516, 0, 2431, 2432, + 3, 1023, 511, 0, 2432, 296, 1, 0, 0, 0, 2433, 2434, 3, 1023, 511, 0, 2434, + 2435, 3, 1017, 508, 0, 2435, 2436, 3, 1055, 527, 0, 2436, 2437, 3, 1017, + 508, 0, 2437, 2438, 3, 1059, 529, 0, 2438, 2439, 3, 1033, 516, 0, 2439, + 2440, 3, 1025, 512, 0, 2440, 2441, 3, 1061, 530, 0, 2441, 298, 1, 0, 0, + 0, 2442, 2443, 3, 1039, 519, 0, 2443, 2444, 3, 1033, 516, 0, 2444, 2445, + 3, 1053, 526, 0, 2445, 2446, 3, 1055, 527, 0, 2446, 2447, 3, 1059, 529, + 0, 2447, 2448, 3, 1033, 516, 0, 2448, 2449, 3, 1025, 512, 0, 2449, 2450, + 3, 1061, 530, 0, 2450, 300, 1, 0, 0, 0, 2451, 2452, 3, 1029, 514, 0, 2452, + 2453, 3, 1017, 508, 0, 2453, 2454, 3, 1039, 519, 0, 2454, 2455, 3, 1039, + 519, 0, 2455, 2456, 3, 1025, 512, 0, 2456, 2457, 3, 1051, 525, 0, 2457, + 2458, 3, 1065, 532, 0, 2458, 302, 1, 0, 0, 0, 2459, 2460, 3, 1021, 510, + 0, 2460, 2461, 3, 1045, 522, 0, 2461, 2462, 3, 1043, 521, 0, 2462, 2463, + 3, 1055, 527, 0, 2463, 2464, 3, 1017, 508, 0, 2464, 2465, 3, 1033, 516, + 0, 2465, 2466, 3, 1043, 521, 0, 2466, 2467, 3, 1025, 512, 0, 2467, 2468, + 3, 1051, 525, 0, 2468, 304, 1, 0, 0, 0, 2469, 2470, 3, 1051, 525, 0, 2470, + 2471, 3, 1045, 522, 0, 2471, 2472, 3, 1061, 530, 0, 2472, 306, 1, 0, 0, + 0, 2473, 2474, 3, 1033, 516, 0, 2474, 2475, 3, 1055, 527, 0, 2475, 2476, + 3, 1025, 512, 0, 2476, 2477, 3, 1041, 520, 0, 2477, 308, 1, 0, 0, 0, 2478, + 2479, 3, 1021, 510, 0, 2479, 2480, 3, 1045, 522, 0, 2480, 2481, 3, 1043, + 521, 0, 2481, 2482, 3, 1055, 527, 0, 2482, 2483, 3, 1051, 525, 0, 2483, + 2484, 3, 1045, 522, 0, 2484, 2485, 3, 1039, 519, 0, 2485, 2486, 3, 1019, + 509, 0, 2486, 2487, 3, 1017, 508, 0, 2487, 2488, 3, 1051, 525, 0, 2488, + 310, 1, 0, 0, 0, 2489, 2490, 3, 1053, 526, 0, 2490, 2491, 3, 1025, 512, + 0, 2491, 2492, 3, 1017, 508, 0, 2492, 2493, 3, 1051, 525, 0, 2493, 2494, + 3, 1021, 510, 0, 2494, 2495, 3, 1031, 515, 0, 2495, 312, 1, 0, 0, 0, 2496, + 2497, 3, 1053, 526, 0, 2497, 2498, 3, 1025, 512, 0, 2498, 2499, 3, 1017, + 508, 0, 2499, 2500, 3, 1051, 525, 0, 2500, 2501, 3, 1021, 510, 0, 2501, + 2502, 3, 1031, 515, 0, 2502, 2503, 3, 1019, 509, 0, 2503, 2504, 3, 1017, + 508, 0, 2504, 2505, 3, 1051, 525, 0, 2505, 314, 1, 0, 0, 0, 2506, 2507, + 3, 1043, 521, 0, 2507, 2508, 3, 1017, 508, 0, 2508, 2509, 3, 1059, 529, + 0, 2509, 2510, 3, 1033, 516, 0, 2510, 2511, 3, 1029, 514, 0, 2511, 2512, + 3, 1017, 508, 0, 2512, 2513, 3, 1055, 527, 0, 2513, 2514, 3, 1033, 516, + 0, 2514, 2515, 3, 1045, 522, 0, 2515, 2516, 3, 1043, 521, 0, 2516, 2517, + 3, 1039, 519, 0, 2517, 2518, 3, 1033, 516, 0, 2518, 2519, 3, 1053, 526, + 0, 2519, 2520, 3, 1055, 527, 0, 2520, 316, 1, 0, 0, 0, 2521, 2522, 3, 1017, + 508, 0, 2522, 2523, 3, 1021, 510, 0, 2523, 2524, 3, 1055, 527, 0, 2524, + 2525, 3, 1033, 516, 0, 2525, 2526, 3, 1045, 522, 0, 2526, 2527, 3, 1043, + 521, 0, 2527, 2528, 3, 1019, 509, 0, 2528, 2529, 3, 1057, 528, 0, 2529, + 2530, 3, 1055, 527, 0, 2530, 2531, 3, 1055, 527, 0, 2531, 2532, 3, 1045, + 522, 0, 2532, 2533, 3, 1043, 521, 0, 2533, 318, 1, 0, 0, 0, 2534, 2535, + 3, 1039, 519, 0, 2535, 2536, 3, 1033, 516, 0, 2536, 2537, 3, 1043, 521, + 0, 2537, 2538, 3, 1037, 518, 0, 2538, 2539, 3, 1019, 509, 0, 2539, 2540, + 3, 1057, 528, 0, 2540, 2541, 3, 1055, 527, 0, 2541, 2542, 3, 1055, 527, + 0, 2542, 2543, 3, 1045, 522, 0, 2543, 2544, 3, 1043, 521, 0, 2544, 320, + 1, 0, 0, 0, 2545, 2546, 3, 1019, 509, 0, 2546, 2547, 3, 1057, 528, 0, 2547, + 2548, 3, 1055, 527, 0, 2548, 2549, 3, 1055, 527, 0, 2549, 2550, 3, 1045, + 522, 0, 2550, 2551, 3, 1043, 521, 0, 2551, 322, 1, 0, 0, 0, 2552, 2553, + 3, 1055, 527, 0, 2553, 2554, 3, 1033, 516, 0, 2554, 2555, 3, 1055, 527, + 0, 2555, 2556, 3, 1039, 519, 0, 2556, 2557, 3, 1025, 512, 0, 2557, 324, + 1, 0, 0, 0, 2558, 2559, 3, 1023, 511, 0, 2559, 2560, 3, 1065, 532, 0, 2560, + 2561, 3, 1043, 521, 0, 2561, 2562, 3, 1017, 508, 0, 2562, 2563, 3, 1041, + 520, 0, 2563, 2564, 3, 1033, 516, 0, 2564, 2565, 3, 1021, 510, 0, 2565, + 2566, 3, 1055, 527, 0, 2566, 2567, 3, 1025, 512, 0, 2567, 2568, 3, 1063, + 531, 0, 2568, 2569, 3, 1055, 527, 0, 2569, 326, 1, 0, 0, 0, 2570, 2571, + 3, 1023, 511, 0, 2571, 2572, 3, 1065, 532, 0, 2572, 2573, 3, 1043, 521, + 0, 2573, 2574, 3, 1017, 508, 0, 2574, 2575, 3, 1041, 520, 0, 2575, 2576, + 3, 1033, 516, 0, 2576, 2577, 3, 1021, 510, 0, 2577, 328, 1, 0, 0, 0, 2578, + 2579, 3, 1053, 526, 0, 2579, 2580, 3, 1055, 527, 0, 2580, 2581, 3, 1017, + 508, 0, 2581, 2582, 3, 1055, 527, 0, 2582, 2583, 3, 1033, 516, 0, 2583, + 2584, 3, 1021, 510, 0, 2584, 2585, 3, 1055, 527, 0, 2585, 2586, 3, 1025, + 512, 0, 2586, 2587, 3, 1063, 531, 0, 2587, 2588, 3, 1055, 527, 0, 2588, + 330, 1, 0, 0, 0, 2589, 2590, 3, 1039, 519, 0, 2590, 2591, 3, 1017, 508, + 0, 2591, 2592, 3, 1019, 509, 0, 2592, 2593, 3, 1025, 512, 0, 2593, 2594, + 3, 1039, 519, 0, 2594, 332, 1, 0, 0, 0, 2595, 2596, 3, 1055, 527, 0, 2596, + 2597, 3, 1025, 512, 0, 2597, 2598, 3, 1063, 531, 0, 2598, 2599, 3, 1055, + 527, 0, 2599, 2600, 3, 1019, 509, 0, 2600, 2601, 3, 1045, 522, 0, 2601, + 2602, 3, 1063, 531, 0, 2602, 334, 1, 0, 0, 0, 2603, 2604, 3, 1055, 527, + 0, 2604, 2605, 3, 1025, 512, 0, 2605, 2606, 3, 1063, 531, 0, 2606, 2607, + 3, 1055, 527, 0, 2607, 2608, 3, 1017, 508, 0, 2608, 2609, 3, 1051, 525, + 0, 2609, 2610, 3, 1025, 512, 0, 2610, 2611, 3, 1017, 508, 0, 2611, 336, + 1, 0, 0, 0, 2612, 2613, 3, 1023, 511, 0, 2613, 2614, 3, 1017, 508, 0, 2614, + 2615, 3, 1055, 527, 0, 2615, 2616, 3, 1025, 512, 0, 2616, 2617, 3, 1047, + 523, 0, 2617, 2618, 3, 1033, 516, 0, 2618, 2619, 3, 1021, 510, 0, 2619, + 2620, 3, 1037, 518, 0, 2620, 2621, 3, 1025, 512, 0, 2621, 2622, 3, 1051, + 525, 0, 2622, 338, 1, 0, 0, 0, 2623, 2624, 3, 1051, 525, 0, 2624, 2625, + 3, 1017, 508, 0, 2625, 2626, 3, 1023, 511, 0, 2626, 2627, 3, 1033, 516, + 0, 2627, 2628, 3, 1045, 522, 0, 2628, 2629, 3, 1019, 509, 0, 2629, 2630, + 3, 1057, 528, 0, 2630, 2631, 3, 1055, 527, 0, 2631, 2632, 3, 1055, 527, + 0, 2632, 2633, 3, 1045, 522, 0, 2633, 2634, 3, 1043, 521, 0, 2634, 2635, + 3, 1053, 526, 0, 2635, 340, 1, 0, 0, 0, 2636, 2637, 3, 1023, 511, 0, 2637, + 2638, 3, 1051, 525, 0, 2638, 2639, 3, 1045, 522, 0, 2639, 2640, 3, 1047, + 523, 0, 2640, 2641, 3, 1023, 511, 0, 2641, 2642, 3, 1045, 522, 0, 2642, + 2643, 3, 1061, 530, 0, 2643, 2644, 3, 1043, 521, 0, 2644, 342, 1, 0, 0, + 0, 2645, 2646, 3, 1021, 510, 0, 2646, 2647, 3, 1045, 522, 0, 2647, 2648, + 3, 1041, 520, 0, 2648, 2649, 3, 1019, 509, 0, 2649, 2650, 3, 1045, 522, + 0, 2650, 2651, 3, 1019, 509, 0, 2651, 2652, 3, 1045, 522, 0, 2652, 2653, + 3, 1063, 531, 0, 2653, 344, 1, 0, 0, 0, 2654, 2655, 3, 1021, 510, 0, 2655, + 2656, 3, 1031, 515, 0, 2656, 2657, 3, 1025, 512, 0, 2657, 2658, 3, 1021, + 510, 0, 2658, 2659, 3, 1037, 518, 0, 2659, 2660, 3, 1019, 509, 0, 2660, + 2661, 3, 1045, 522, 0, 2661, 2662, 3, 1063, 531, 0, 2662, 346, 1, 0, 0, + 0, 2663, 2664, 3, 1051, 525, 0, 2664, 2665, 3, 1025, 512, 0, 2665, 2666, + 3, 1027, 513, 0, 2666, 2667, 3, 1025, 512, 0, 2667, 2668, 3, 1051, 525, + 0, 2668, 2669, 3, 1025, 512, 0, 2669, 2670, 3, 1043, 521, 0, 2670, 2671, + 3, 1021, 510, 0, 2671, 2672, 3, 1025, 512, 0, 2672, 2673, 3, 1053, 526, + 0, 2673, 2674, 3, 1025, 512, 0, 2674, 2675, 3, 1039, 519, 0, 2675, 2676, + 3, 1025, 512, 0, 2676, 2677, 3, 1021, 510, 0, 2677, 2678, 3, 1055, 527, + 0, 2678, 2679, 3, 1045, 522, 0, 2679, 2680, 3, 1051, 525, 0, 2680, 348, + 1, 0, 0, 0, 2681, 2682, 3, 1033, 516, 0, 2682, 2683, 3, 1043, 521, 0, 2683, + 2684, 3, 1047, 523, 0, 2684, 2685, 3, 1057, 528, 0, 2685, 2686, 3, 1055, + 527, 0, 2686, 2687, 3, 1051, 525, 0, 2687, 2688, 3, 1025, 512, 0, 2688, + 2689, 3, 1027, 513, 0, 2689, 2690, 3, 1025, 512, 0, 2690, 2691, 3, 1051, + 525, 0, 2691, 2692, 3, 1025, 512, 0, 2692, 2693, 3, 1043, 521, 0, 2693, + 2694, 3, 1021, 510, 0, 2694, 2695, 3, 1025, 512, 0, 2695, 2696, 3, 1053, + 526, 0, 2696, 2697, 3, 1025, 512, 0, 2697, 2698, 3, 1055, 527, 0, 2698, + 2699, 3, 1053, 526, 0, 2699, 2700, 3, 1025, 512, 0, 2700, 2701, 3, 1039, + 519, 0, 2701, 2702, 3, 1025, 512, 0, 2702, 2703, 3, 1021, 510, 0, 2703, + 2704, 3, 1055, 527, 0, 2704, 2705, 3, 1045, 522, 0, 2705, 2706, 3, 1051, + 525, 0, 2706, 350, 1, 0, 0, 0, 2707, 2708, 3, 1027, 513, 0, 2708, 2709, + 3, 1033, 516, 0, 2709, 2710, 3, 1039, 519, 0, 2710, 2711, 3, 1025, 512, + 0, 2711, 2712, 3, 1033, 516, 0, 2712, 2713, 3, 1043, 521, 0, 2713, 2714, + 3, 1047, 523, 0, 2714, 2715, 3, 1057, 528, 0, 2715, 2716, 3, 1055, 527, + 0, 2716, 352, 1, 0, 0, 0, 2717, 2718, 3, 1033, 516, 0, 2718, 2719, 3, 1041, + 520, 0, 2719, 2720, 3, 1017, 508, 0, 2720, 2721, 3, 1029, 514, 0, 2721, + 2722, 3, 1025, 512, 0, 2722, 2723, 3, 1033, 516, 0, 2723, 2724, 3, 1043, + 521, 0, 2724, 2725, 3, 1047, 523, 0, 2725, 2726, 3, 1057, 528, 0, 2726, + 2727, 3, 1055, 527, 0, 2727, 354, 1, 0, 0, 0, 2728, 2729, 3, 1021, 510, + 0, 2729, 2730, 3, 1057, 528, 0, 2730, 2731, 3, 1053, 526, 0, 2731, 2732, + 3, 1055, 527, 0, 2732, 2733, 3, 1045, 522, 0, 2733, 2734, 3, 1041, 520, + 0, 2734, 2735, 3, 1061, 530, 0, 2735, 2736, 3, 1033, 516, 0, 2736, 2737, + 3, 1023, 511, 0, 2737, 2738, 3, 1029, 514, 0, 2738, 2739, 3, 1025, 512, + 0, 2739, 2740, 3, 1055, 527, 0, 2740, 356, 1, 0, 0, 0, 2741, 2742, 3, 1055, + 527, 0, 2742, 2743, 3, 1025, 512, 0, 2743, 2744, 3, 1063, 531, 0, 2744, + 2745, 3, 1055, 527, 0, 2745, 2746, 3, 1027, 513, 0, 2746, 2747, 3, 1033, + 516, 0, 2747, 2748, 3, 1039, 519, 0, 2748, 2749, 3, 1055, 527, 0, 2749, + 2750, 3, 1025, 512, 0, 2750, 2751, 3, 1051, 525, 0, 2751, 358, 1, 0, 0, + 0, 2752, 2753, 3, 1043, 521, 0, 2753, 2754, 3, 1057, 528, 0, 2754, 2755, + 3, 1041, 520, 0, 2755, 2756, 3, 1019, 509, 0, 2756, 2757, 3, 1025, 512, + 0, 2757, 2758, 3, 1051, 525, 0, 2758, 2759, 3, 1027, 513, 0, 2759, 2760, + 3, 1033, 516, 0, 2760, 2761, 3, 1039, 519, 0, 2761, 2762, 3, 1055, 527, + 0, 2762, 2763, 3, 1025, 512, 0, 2763, 2764, 3, 1051, 525, 0, 2764, 360, + 1, 0, 0, 0, 2765, 2766, 3, 1023, 511, 0, 2766, 2767, 3, 1051, 525, 0, 2767, + 2768, 3, 1045, 522, 0, 2768, 2769, 3, 1047, 523, 0, 2769, 2770, 3, 1023, + 511, 0, 2770, 2771, 3, 1045, 522, 0, 2771, 2772, 3, 1061, 530, 0, 2772, + 2773, 3, 1043, 521, 0, 2773, 2774, 3, 1027, 513, 0, 2774, 2775, 3, 1033, + 516, 0, 2775, 2776, 3, 1039, 519, 0, 2776, 2777, 3, 1055, 527, 0, 2777, + 2778, 3, 1025, 512, 0, 2778, 2779, 3, 1051, 525, 0, 2779, 362, 1, 0, 0, + 0, 2780, 2781, 3, 1023, 511, 0, 2781, 2782, 3, 1017, 508, 0, 2782, 2783, + 3, 1055, 527, 0, 2783, 2784, 3, 1025, 512, 0, 2784, 2785, 3, 1027, 513, + 0, 2785, 2786, 3, 1033, 516, 0, 2786, 2787, 3, 1039, 519, 0, 2787, 2788, + 3, 1055, 527, 0, 2788, 2789, 3, 1025, 512, 0, 2789, 2790, 3, 1051, 525, + 0, 2790, 364, 1, 0, 0, 0, 2791, 2792, 3, 1027, 513, 0, 2792, 2793, 3, 1033, + 516, 0, 2793, 2794, 3, 1039, 519, 0, 2794, 2795, 3, 1055, 527, 0, 2795, + 2796, 3, 1025, 512, 0, 2796, 2797, 3, 1051, 525, 0, 2797, 366, 1, 0, 0, + 0, 2798, 2799, 3, 1061, 530, 0, 2799, 2800, 3, 1033, 516, 0, 2800, 2801, + 3, 1023, 511, 0, 2801, 2802, 3, 1029, 514, 0, 2802, 2803, 3, 1025, 512, + 0, 2803, 2804, 3, 1055, 527, 0, 2804, 368, 1, 0, 0, 0, 2805, 2806, 3, 1061, + 530, 0, 2806, 2807, 3, 1033, 516, 0, 2807, 2808, 3, 1023, 511, 0, 2808, + 2809, 3, 1029, 514, 0, 2809, 2810, 3, 1025, 512, 0, 2810, 2811, 3, 1055, + 527, 0, 2811, 2812, 3, 1053, 526, 0, 2812, 370, 1, 0, 0, 0, 2813, 2814, + 3, 1021, 510, 0, 2814, 2815, 3, 1017, 508, 0, 2815, 2816, 3, 1047, 523, + 0, 2816, 2817, 3, 1055, 527, 0, 2817, 2818, 3, 1033, 516, 0, 2818, 2819, + 3, 1045, 522, 0, 2819, 2820, 3, 1043, 521, 0, 2820, 372, 1, 0, 0, 0, 2821, + 2822, 3, 1033, 516, 0, 2822, 2823, 3, 1021, 510, 0, 2823, 2824, 3, 1045, + 522, 0, 2824, 2825, 3, 1043, 521, 0, 2825, 374, 1, 0, 0, 0, 2826, 2827, + 3, 1055, 527, 0, 2827, 2828, 3, 1045, 522, 0, 2828, 2829, 3, 1045, 522, + 0, 2829, 2830, 3, 1039, 519, 0, 2830, 2831, 3, 1055, 527, 0, 2831, 2832, + 3, 1033, 516, 0, 2832, 2833, 3, 1047, 523, 0, 2833, 376, 1, 0, 0, 0, 2834, + 2835, 3, 1023, 511, 0, 2835, 2836, 3, 1017, 508, 0, 2836, 2837, 3, 1055, + 527, 0, 2837, 2838, 3, 1017, 508, 0, 2838, 2839, 3, 1053, 526, 0, 2839, + 2840, 3, 1045, 522, 0, 2840, 2841, 3, 1057, 528, 0, 2841, 2842, 3, 1051, + 525, 0, 2842, 2843, 3, 1021, 510, 0, 2843, 2844, 3, 1025, 512, 0, 2844, + 378, 1, 0, 0, 0, 2845, 2846, 3, 1053, 526, 0, 2846, 2847, 3, 1045, 522, + 0, 2847, 2848, 3, 1057, 528, 0, 2848, 2849, 3, 1051, 525, 0, 2849, 2850, + 3, 1021, 510, 0, 2850, 2851, 3, 1025, 512, 0, 2851, 380, 1, 0, 0, 0, 2852, + 2853, 3, 1053, 526, 0, 2853, 2854, 3, 1025, 512, 0, 2854, 2855, 3, 1039, + 519, 0, 2855, 2856, 3, 1025, 512, 0, 2856, 2857, 3, 1021, 510, 0, 2857, + 2858, 3, 1055, 527, 0, 2858, 2859, 3, 1033, 516, 0, 2859, 2860, 3, 1045, + 522, 0, 2860, 2861, 3, 1043, 521, 0, 2861, 382, 1, 0, 0, 0, 2862, 2863, + 3, 1027, 513, 0, 2863, 2864, 3, 1045, 522, 0, 2864, 2865, 3, 1045, 522, + 0, 2865, 2866, 3, 1055, 527, 0, 2866, 2867, 3, 1025, 512, 0, 2867, 2868, + 3, 1051, 525, 0, 2868, 384, 1, 0, 0, 0, 2869, 2870, 3, 1031, 515, 0, 2870, + 2871, 3, 1025, 512, 0, 2871, 2872, 3, 1017, 508, 0, 2872, 2873, 3, 1023, + 511, 0, 2873, 2874, 3, 1025, 512, 0, 2874, 2875, 3, 1051, 525, 0, 2875, + 386, 1, 0, 0, 0, 2876, 2877, 3, 1021, 510, 0, 2877, 2878, 3, 1045, 522, + 0, 2878, 2879, 3, 1043, 521, 0, 2879, 2880, 3, 1055, 527, 0, 2880, 2881, + 3, 1025, 512, 0, 2881, 2882, 3, 1043, 521, 0, 2882, 2883, 3, 1055, 527, + 0, 2883, 388, 1, 0, 0, 0, 2884, 2885, 3, 1051, 525, 0, 2885, 2886, 3, 1025, + 512, 0, 2886, 2887, 3, 1043, 521, 0, 2887, 2888, 3, 1023, 511, 0, 2888, + 2889, 3, 1025, 512, 0, 2889, 2890, 3, 1051, 525, 0, 2890, 2891, 3, 1041, + 520, 0, 2891, 2892, 3, 1045, 522, 0, 2892, 2893, 3, 1023, 511, 0, 2893, + 2894, 3, 1025, 512, 0, 2894, 390, 1, 0, 0, 0, 2895, 2896, 3, 1019, 509, + 0, 2896, 2897, 3, 1033, 516, 0, 2897, 2898, 3, 1043, 521, 0, 2898, 2899, + 3, 1023, 511, 0, 2899, 2900, 3, 1053, 526, 0, 2900, 392, 1, 0, 0, 0, 2901, + 2902, 3, 1017, 508, 0, 2902, 2903, 3, 1055, 527, 0, 2903, 2904, 3, 1055, + 527, 0, 2904, 2905, 3, 1051, 525, 0, 2905, 394, 1, 0, 0, 0, 2906, 2907, + 3, 1021, 510, 0, 2907, 2908, 3, 1045, 522, 0, 2908, 2909, 3, 1043, 521, + 0, 2909, 2910, 3, 1055, 527, 0, 2910, 2911, 3, 1025, 512, 0, 2911, 2912, + 3, 1043, 521, 0, 2912, 2913, 3, 1055, 527, 0, 2913, 2914, 3, 1047, 523, + 0, 2914, 2915, 3, 1017, 508, 0, 2915, 2916, 3, 1051, 525, 0, 2916, 2917, + 3, 1017, 508, 0, 2917, 2918, 3, 1041, 520, 0, 2918, 2919, 3, 1053, 526, + 0, 2919, 396, 1, 0, 0, 0, 2920, 2921, 3, 1021, 510, 0, 2921, 2922, 3, 1017, + 508, 0, 2922, 2923, 3, 1047, 523, 0, 2923, 2924, 3, 1055, 527, 0, 2924, + 2925, 3, 1033, 516, 0, 2925, 2926, 3, 1045, 522, 0, 2926, 2927, 3, 1043, + 521, 0, 2927, 2928, 3, 1047, 523, 0, 2928, 2929, 3, 1017, 508, 0, 2929, + 2930, 3, 1051, 525, 0, 2930, 2931, 3, 1017, 508, 0, 2931, 2932, 3, 1041, + 520, 0, 2932, 2933, 3, 1053, 526, 0, 2933, 398, 1, 0, 0, 0, 2934, 2935, + 3, 1047, 523, 0, 2935, 2936, 3, 1017, 508, 0, 2936, 2937, 3, 1051, 525, + 0, 2937, 2938, 3, 1017, 508, 0, 2938, 2939, 3, 1041, 520, 0, 2939, 2940, + 3, 1053, 526, 0, 2940, 400, 1, 0, 0, 0, 2941, 2942, 3, 1059, 529, 0, 2942, + 2943, 3, 1017, 508, 0, 2943, 2944, 3, 1051, 525, 0, 2944, 2945, 3, 1033, + 516, 0, 2945, 2946, 3, 1017, 508, 0, 2946, 2947, 3, 1019, 509, 0, 2947, + 2948, 3, 1039, 519, 0, 2948, 2949, 3, 1025, 512, 0, 2949, 2950, 3, 1053, + 526, 0, 2950, 402, 1, 0, 0, 0, 2951, 2952, 3, 1023, 511, 0, 2952, 2953, + 3, 1025, 512, 0, 2953, 2954, 3, 1053, 526, 0, 2954, 2955, 3, 1037, 518, + 0, 2955, 2956, 3, 1055, 527, 0, 2956, 2957, 3, 1045, 522, 0, 2957, 2958, + 3, 1047, 523, 0, 2958, 2959, 3, 1061, 530, 0, 2959, 2960, 3, 1033, 516, + 0, 2960, 2961, 3, 1023, 511, 0, 2961, 2962, 3, 1055, 527, 0, 2962, 2963, + 3, 1031, 515, 0, 2963, 404, 1, 0, 0, 0, 2964, 2965, 3, 1021, 510, 0, 2965, + 2966, 3, 1039, 519, 0, 2966, 2967, 3, 1017, 508, 0, 2967, 2968, 3, 1053, + 526, 0, 2968, 2969, 3, 1053, 526, 0, 2969, 406, 1, 0, 0, 0, 2970, 2971, + 3, 1053, 526, 0, 2971, 2972, 3, 1055, 527, 0, 2972, 2973, 3, 1065, 532, + 0, 2973, 2974, 3, 1039, 519, 0, 2974, 2975, 3, 1025, 512, 0, 2975, 408, + 1, 0, 0, 0, 2976, 2977, 3, 1019, 509, 0, 2977, 2978, 3, 1057, 528, 0, 2978, + 2979, 3, 1055, 527, 0, 2979, 2980, 3, 1055, 527, 0, 2980, 2981, 3, 1045, + 522, 0, 2981, 2982, 3, 1043, 521, 0, 2982, 2983, 3, 1053, 526, 0, 2983, + 2984, 3, 1055, 527, 0, 2984, 2985, 3, 1065, 532, 0, 2985, 2986, 3, 1039, + 519, 0, 2986, 2987, 3, 1025, 512, 0, 2987, 410, 1, 0, 0, 0, 2988, 2989, + 3, 1023, 511, 0, 2989, 2990, 3, 1025, 512, 0, 2990, 2991, 3, 1053, 526, + 0, 2991, 2992, 3, 1033, 516, 0, 2992, 2993, 3, 1029, 514, 0, 2993, 2994, + 3, 1043, 521, 0, 2994, 412, 1, 0, 0, 0, 2995, 2996, 3, 1047, 523, 0, 2996, + 2997, 3, 1051, 525, 0, 2997, 2998, 3, 1045, 522, 0, 2998, 2999, 3, 1047, + 523, 0, 2999, 3000, 3, 1025, 512, 0, 3000, 3001, 3, 1051, 525, 0, 3001, + 3002, 3, 1055, 527, 0, 3002, 3003, 3, 1033, 516, 0, 3003, 3004, 3, 1025, + 512, 0, 3004, 3005, 3, 1053, 526, 0, 3005, 414, 1, 0, 0, 0, 3006, 3007, + 3, 1023, 511, 0, 3007, 3008, 3, 1025, 512, 0, 3008, 3009, 3, 1053, 526, + 0, 3009, 3010, 3, 1033, 516, 0, 3010, 3011, 3, 1029, 514, 0, 3011, 3012, + 3, 1043, 521, 0, 3012, 3013, 3, 1047, 523, 0, 3013, 3014, 3, 1051, 525, + 0, 3014, 3015, 3, 1045, 522, 0, 3015, 3016, 3, 1047, 523, 0, 3016, 3017, + 3, 1025, 512, 0, 3017, 3018, 3, 1051, 525, 0, 3018, 3019, 3, 1055, 527, + 0, 3019, 3020, 3, 1033, 516, 0, 3020, 3021, 3, 1025, 512, 0, 3021, 3022, + 3, 1053, 526, 0, 3022, 416, 1, 0, 0, 0, 3023, 3024, 3, 1053, 526, 0, 3024, + 3025, 3, 1055, 527, 0, 3025, 3026, 3, 1065, 532, 0, 3026, 3027, 3, 1039, + 519, 0, 3027, 3028, 3, 1033, 516, 0, 3028, 3029, 3, 1043, 521, 0, 3029, + 3030, 3, 1029, 514, 0, 3030, 418, 1, 0, 0, 0, 3031, 3032, 3, 1021, 510, + 0, 3032, 3033, 3, 1039, 519, 0, 3033, 3034, 3, 1025, 512, 0, 3034, 3035, + 3, 1017, 508, 0, 3035, 3036, 3, 1051, 525, 0, 3036, 420, 1, 0, 0, 0, 3037, + 3038, 3, 1061, 530, 0, 3038, 3039, 3, 1033, 516, 0, 3039, 3040, 3, 1023, + 511, 0, 3040, 3041, 3, 1055, 527, 0, 3041, 3042, 3, 1031, 515, 0, 3042, + 422, 1, 0, 0, 0, 3043, 3044, 3, 1031, 515, 0, 3044, 3045, 3, 1025, 512, + 0, 3045, 3046, 3, 1033, 516, 0, 3046, 3047, 3, 1029, 514, 0, 3047, 3048, + 3, 1031, 515, 0, 3048, 3049, 3, 1055, 527, 0, 3049, 424, 1, 0, 0, 0, 3050, + 3051, 3, 1017, 508, 0, 3051, 3052, 3, 1057, 528, 0, 3052, 3053, 3, 1055, + 527, 0, 3053, 3054, 3, 1045, 522, 0, 3054, 3055, 3, 1027, 513, 0, 3055, + 3056, 3, 1033, 516, 0, 3056, 3057, 3, 1039, 519, 0, 3057, 3058, 3, 1039, + 519, 0, 3058, 426, 1, 0, 0, 0, 3059, 3060, 3, 1057, 528, 0, 3060, 3061, + 3, 1051, 525, 0, 3061, 3062, 3, 1039, 519, 0, 3062, 428, 1, 0, 0, 0, 3063, + 3064, 3, 1027, 513, 0, 3064, 3065, 3, 1045, 522, 0, 3065, 3066, 3, 1039, + 519, 0, 3066, 3067, 3, 1023, 511, 0, 3067, 3068, 3, 1025, 512, 0, 3068, + 3069, 3, 1051, 525, 0, 3069, 430, 1, 0, 0, 0, 3070, 3071, 3, 1047, 523, + 0, 3071, 3072, 3, 1017, 508, 0, 3072, 3073, 3, 1053, 526, 0, 3073, 3074, + 3, 1053, 526, 0, 3074, 3075, 3, 1033, 516, 0, 3075, 3076, 3, 1043, 521, + 0, 3076, 3077, 3, 1029, 514, 0, 3077, 432, 1, 0, 0, 0, 3078, 3079, 3, 1021, + 510, 0, 3079, 3080, 3, 1045, 522, 0, 3080, 3081, 3, 1043, 521, 0, 3081, + 3082, 3, 1055, 527, 0, 3082, 3083, 3, 1025, 512, 0, 3083, 3084, 3, 1063, + 531, 0, 3084, 3085, 3, 1055, 527, 0, 3085, 434, 1, 0, 0, 0, 3086, 3087, + 3, 1025, 512, 0, 3087, 3088, 3, 1023, 511, 0, 3088, 3089, 3, 1033, 516, + 0, 3089, 3090, 3, 1055, 527, 0, 3090, 3091, 3, 1017, 508, 0, 3091, 3092, + 3, 1019, 509, 0, 3092, 3093, 3, 1039, 519, 0, 3093, 3094, 3, 1025, 512, + 0, 3094, 436, 1, 0, 0, 0, 3095, 3096, 3, 1051, 525, 0, 3096, 3097, 3, 1025, + 512, 0, 3097, 3098, 3, 1017, 508, 0, 3098, 3099, 3, 1023, 511, 0, 3099, + 3100, 3, 1045, 522, 0, 3100, 3101, 3, 1043, 521, 0, 3101, 3102, 3, 1039, + 519, 0, 3102, 3103, 3, 1065, 532, 0, 3103, 438, 1, 0, 0, 0, 3104, 3105, + 3, 1017, 508, 0, 3105, 3106, 3, 1055, 527, 0, 3106, 3107, 3, 1055, 527, + 0, 3107, 3108, 3, 1051, 525, 0, 3108, 3109, 3, 1033, 516, 0, 3109, 3110, + 3, 1019, 509, 0, 3110, 3111, 3, 1057, 528, 0, 3111, 3112, 3, 1055, 527, + 0, 3112, 3113, 3, 1025, 512, 0, 3113, 3114, 3, 1053, 526, 0, 3114, 440, + 1, 0, 0, 0, 3115, 3116, 3, 1027, 513, 0, 3116, 3117, 3, 1033, 516, 0, 3117, + 3118, 3, 1039, 519, 0, 3118, 3119, 3, 1055, 527, 0, 3119, 3120, 3, 1025, + 512, 0, 3120, 3121, 3, 1051, 525, 0, 3121, 3122, 3, 1055, 527, 0, 3122, + 3123, 3, 1065, 532, 0, 3123, 3124, 3, 1047, 523, 0, 3124, 3125, 3, 1025, + 512, 0, 3125, 442, 1, 0, 0, 0, 3126, 3127, 3, 1033, 516, 0, 3127, 3128, + 3, 1041, 520, 0, 3128, 3129, 3, 1017, 508, 0, 3129, 3130, 3, 1029, 514, + 0, 3130, 3131, 3, 1025, 512, 0, 3131, 444, 1, 0, 0, 0, 3132, 3133, 3, 1053, + 526, 0, 3133, 3134, 3, 1055, 527, 0, 3134, 3135, 3, 1017, 508, 0, 3135, + 3136, 3, 1055, 527, 0, 3136, 3137, 3, 1033, 516, 0, 3137, 3138, 3, 1021, + 510, 0, 3138, 3139, 3, 1033, 516, 0, 3139, 3140, 3, 1041, 520, 0, 3140, + 3141, 3, 1017, 508, 0, 3141, 3142, 3, 1029, 514, 0, 3142, 3143, 3, 1025, + 512, 0, 3143, 446, 1, 0, 0, 0, 3144, 3145, 3, 1023, 511, 0, 3145, 3146, + 3, 1065, 532, 0, 3146, 3147, 3, 1043, 521, 0, 3147, 3148, 3, 1017, 508, + 0, 3148, 3149, 3, 1041, 520, 0, 3149, 3150, 3, 1033, 516, 0, 3150, 3151, + 3, 1021, 510, 0, 3151, 3152, 3, 1033, 516, 0, 3152, 3153, 3, 1041, 520, + 0, 3153, 3154, 3, 1017, 508, 0, 3154, 3155, 3, 1029, 514, 0, 3155, 3156, + 3, 1025, 512, 0, 3156, 448, 1, 0, 0, 0, 3157, 3158, 3, 1021, 510, 0, 3158, + 3159, 3, 1057, 528, 0, 3159, 3160, 3, 1053, 526, 0, 3160, 3161, 3, 1055, + 527, 0, 3161, 3162, 3, 1045, 522, 0, 3162, 3163, 3, 1041, 520, 0, 3163, + 3164, 3, 1021, 510, 0, 3164, 3165, 3, 1045, 522, 0, 3165, 3166, 3, 1043, + 521, 0, 3166, 3167, 3, 1055, 527, 0, 3167, 3168, 3, 1017, 508, 0, 3168, + 3169, 3, 1033, 516, 0, 3169, 3170, 3, 1043, 521, 0, 3170, 3171, 3, 1025, + 512, 0, 3171, 3172, 3, 1051, 525, 0, 3172, 450, 1, 0, 0, 0, 3173, 3174, + 3, 1029, 514, 0, 3174, 3175, 3, 1051, 525, 0, 3175, 3176, 3, 1045, 522, + 0, 3176, 3177, 3, 1057, 528, 0, 3177, 3178, 3, 1047, 523, 0, 3178, 3179, + 3, 1019, 509, 0, 3179, 3180, 3, 1045, 522, 0, 3180, 3181, 3, 1063, 531, + 0, 3181, 452, 1, 0, 0, 0, 3182, 3183, 3, 1059, 529, 0, 3183, 3184, 3, 1033, + 516, 0, 3184, 3185, 3, 1053, 526, 0, 3185, 3186, 3, 1033, 516, 0, 3186, + 3187, 3, 1019, 509, 0, 3187, 3188, 3, 1039, 519, 0, 3188, 3189, 3, 1025, + 512, 0, 3189, 454, 1, 0, 0, 0, 3190, 3191, 3, 1053, 526, 0, 3191, 3192, + 3, 1017, 508, 0, 3192, 3193, 3, 1059, 529, 0, 3193, 3194, 3, 1025, 512, + 0, 3194, 3195, 3, 1021, 510, 0, 3195, 3196, 3, 1031, 515, 0, 3196, 3197, + 3, 1017, 508, 0, 3197, 3198, 3, 1043, 521, 0, 3198, 3199, 3, 1029, 514, + 0, 3199, 3200, 3, 1025, 512, 0, 3200, 3201, 3, 1053, 526, 0, 3201, 456, + 1, 0, 0, 0, 3202, 3203, 3, 1053, 526, 0, 3203, 3204, 3, 1017, 508, 0, 3204, + 3205, 3, 1059, 529, 0, 3205, 3206, 3, 1025, 512, 0, 3206, 3207, 5, 95, + 0, 0, 3207, 3208, 3, 1021, 510, 0, 3208, 3209, 3, 1031, 515, 0, 3209, 3210, + 3, 1017, 508, 0, 3210, 3211, 3, 1043, 521, 0, 3211, 3212, 3, 1029, 514, + 0, 3212, 3213, 3, 1025, 512, 0, 3213, 3214, 3, 1053, 526, 0, 3214, 458, + 1, 0, 0, 0, 3215, 3216, 3, 1021, 510, 0, 3216, 3217, 3, 1017, 508, 0, 3217, + 3218, 3, 1043, 521, 0, 3218, 3219, 3, 1021, 510, 0, 3219, 3220, 3, 1025, + 512, 0, 3220, 3221, 3, 1039, 519, 0, 3221, 3222, 5, 95, 0, 0, 3222, 3223, + 3, 1021, 510, 0, 3223, 3224, 3, 1031, 515, 0, 3224, 3225, 3, 1017, 508, + 0, 3225, 3226, 3, 1043, 521, 0, 3226, 3227, 3, 1029, 514, 0, 3227, 3228, + 3, 1025, 512, 0, 3228, 3229, 3, 1053, 526, 0, 3229, 460, 1, 0, 0, 0, 3230, + 3231, 3, 1021, 510, 0, 3231, 3232, 3, 1039, 519, 0, 3232, 3233, 3, 1045, + 522, 0, 3233, 3234, 3, 1053, 526, 0, 3234, 3235, 3, 1025, 512, 0, 3235, + 3236, 5, 95, 0, 0, 3236, 3237, 3, 1047, 523, 0, 3237, 3238, 3, 1017, 508, + 0, 3238, 3239, 3, 1029, 514, 0, 3239, 3240, 3, 1025, 512, 0, 3240, 462, + 1, 0, 0, 0, 3241, 3242, 3, 1053, 526, 0, 3242, 3243, 3, 1031, 515, 0, 3243, + 3244, 3, 1045, 522, 0, 3244, 3245, 3, 1061, 530, 0, 3245, 3246, 5, 95, + 0, 0, 3246, 3247, 3, 1047, 523, 0, 3247, 3248, 3, 1017, 508, 0, 3248, 3249, + 3, 1029, 514, 0, 3249, 3250, 3, 1025, 512, 0, 3250, 464, 1, 0, 0, 0, 3251, + 3252, 3, 1023, 511, 0, 3252, 3253, 3, 1025, 512, 0, 3253, 3254, 3, 1039, + 519, 0, 3254, 3255, 3, 1025, 512, 0, 3255, 3256, 3, 1055, 527, 0, 3256, + 3257, 3, 1025, 512, 0, 3257, 3258, 5, 95, 0, 0, 3258, 3259, 3, 1017, 508, + 0, 3259, 3260, 3, 1021, 510, 0, 3260, 3261, 3, 1055, 527, 0, 3261, 3262, + 3, 1033, 516, 0, 3262, 3263, 3, 1045, 522, 0, 3263, 3264, 3, 1043, 521, + 0, 3264, 466, 1, 0, 0, 0, 3265, 3266, 3, 1023, 511, 0, 3266, 3267, 3, 1025, + 512, 0, 3267, 3268, 3, 1039, 519, 0, 3268, 3269, 3, 1025, 512, 0, 3269, + 3270, 3, 1055, 527, 0, 3270, 3271, 3, 1025, 512, 0, 3271, 3272, 5, 95, + 0, 0, 3272, 3273, 3, 1045, 522, 0, 3273, 3274, 3, 1019, 509, 0, 3274, 3275, + 3, 1035, 517, 0, 3275, 3276, 3, 1025, 512, 0, 3276, 3277, 3, 1021, 510, + 0, 3277, 3278, 3, 1055, 527, 0, 3278, 468, 1, 0, 0, 0, 3279, 3280, 3, 1021, + 510, 0, 3280, 3281, 3, 1051, 525, 0, 3281, 3282, 3, 1025, 512, 0, 3282, + 3283, 3, 1017, 508, 0, 3283, 3284, 3, 1055, 527, 0, 3284, 3285, 3, 1025, + 512, 0, 3285, 3286, 5, 95, 0, 0, 3286, 3287, 3, 1045, 522, 0, 3287, 3288, + 3, 1019, 509, 0, 3288, 3289, 3, 1035, 517, 0, 3289, 3290, 3, 1025, 512, + 0, 3290, 3291, 3, 1021, 510, 0, 3291, 3292, 3, 1055, 527, 0, 3292, 470, + 1, 0, 0, 0, 3293, 3294, 3, 1021, 510, 0, 3294, 3295, 3, 1017, 508, 0, 3295, + 3296, 3, 1039, 519, 0, 3296, 3297, 3, 1039, 519, 0, 3297, 3298, 5, 95, + 0, 0, 3298, 3299, 3, 1041, 520, 0, 3299, 3300, 3, 1033, 516, 0, 3300, 3301, + 3, 1021, 510, 0, 3301, 3302, 3, 1051, 525, 0, 3302, 3303, 3, 1045, 522, + 0, 3303, 3304, 3, 1027, 513, 0, 3304, 3305, 3, 1039, 519, 0, 3305, 3306, + 3, 1045, 522, 0, 3306, 3307, 3, 1061, 530, 0, 3307, 472, 1, 0, 0, 0, 3308, + 3309, 3, 1021, 510, 0, 3309, 3310, 3, 1017, 508, 0, 3310, 3311, 3, 1039, + 519, 0, 3311, 3312, 3, 1039, 519, 0, 3312, 3313, 5, 95, 0, 0, 3313, 3314, + 3, 1043, 521, 0, 3314, 3315, 3, 1017, 508, 0, 3315, 3316, 3, 1043, 521, + 0, 3316, 3317, 3, 1045, 522, 0, 3317, 3318, 3, 1027, 513, 0, 3318, 3319, + 3, 1039, 519, 0, 3319, 3320, 3, 1045, 522, 0, 3320, 3321, 3, 1061, 530, + 0, 3321, 474, 1, 0, 0, 0, 3322, 3323, 3, 1045, 522, 0, 3323, 3324, 3, 1047, + 523, 0, 3324, 3325, 3, 1025, 512, 0, 3325, 3326, 3, 1043, 521, 0, 3326, + 3327, 5, 95, 0, 0, 3327, 3328, 3, 1039, 519, 0, 3328, 3329, 3, 1033, 516, + 0, 3329, 3330, 3, 1043, 521, 0, 3330, 3331, 3, 1037, 518, 0, 3331, 476, + 1, 0, 0, 0, 3332, 3333, 3, 1053, 526, 0, 3333, 3334, 3, 1033, 516, 0, 3334, + 3335, 3, 1029, 514, 0, 3335, 3336, 3, 1043, 521, 0, 3336, 3337, 5, 95, + 0, 0, 3337, 3338, 3, 1045, 522, 0, 3338, 3339, 3, 1057, 528, 0, 3339, 3340, + 3, 1055, 527, 0, 3340, 478, 1, 0, 0, 0, 3341, 3342, 3, 1021, 510, 0, 3342, + 3343, 3, 1017, 508, 0, 3343, 3344, 3, 1043, 521, 0, 3344, 3345, 3, 1021, + 510, 0, 3345, 3346, 3, 1025, 512, 0, 3346, 3347, 3, 1039, 519, 0, 3347, + 480, 1, 0, 0, 0, 3348, 3349, 3, 1047, 523, 0, 3349, 3350, 3, 1051, 525, + 0, 3350, 3351, 3, 1033, 516, 0, 3351, 3352, 3, 1041, 520, 0, 3352, 3353, + 3, 1017, 508, 0, 3353, 3354, 3, 1051, 525, 0, 3354, 3355, 3, 1065, 532, + 0, 3355, 482, 1, 0, 0, 0, 3356, 3357, 3, 1053, 526, 0, 3357, 3358, 3, 1057, + 528, 0, 3358, 3359, 3, 1021, 510, 0, 3359, 3360, 3, 1021, 510, 0, 3360, + 3361, 3, 1025, 512, 0, 3361, 3362, 3, 1053, 526, 0, 3362, 3363, 3, 1053, + 526, 0, 3363, 484, 1, 0, 0, 0, 3364, 3365, 3, 1023, 511, 0, 3365, 3366, + 3, 1017, 508, 0, 3366, 3367, 3, 1043, 521, 0, 3367, 3368, 3, 1029, 514, + 0, 3368, 3369, 3, 1025, 512, 0, 3369, 3370, 3, 1051, 525, 0, 3370, 486, + 1, 0, 0, 0, 3371, 3372, 3, 1061, 530, 0, 3372, 3373, 3, 1017, 508, 0, 3373, + 3374, 3, 1051, 525, 0, 3374, 3375, 3, 1043, 521, 0, 3375, 3376, 3, 1033, + 516, 0, 3376, 3377, 3, 1043, 521, 0, 3377, 3378, 3, 1029, 514, 0, 3378, + 488, 1, 0, 0, 0, 3379, 3380, 3, 1033, 516, 0, 3380, 3381, 3, 1043, 521, + 0, 3381, 3382, 3, 1027, 513, 0, 3382, 3383, 3, 1045, 522, 0, 3383, 490, + 1, 0, 0, 0, 3384, 3385, 3, 1055, 527, 0, 3385, 3386, 3, 1025, 512, 0, 3386, + 3387, 3, 1041, 520, 0, 3387, 3388, 3, 1047, 523, 0, 3388, 3389, 3, 1039, + 519, 0, 3389, 3390, 3, 1017, 508, 0, 3390, 3391, 3, 1055, 527, 0, 3391, + 3392, 3, 1025, 512, 0, 3392, 492, 1, 0, 0, 0, 3393, 3394, 3, 1045, 522, + 0, 3394, 3395, 3, 1043, 521, 0, 3395, 3396, 3, 1021, 510, 0, 3396, 3397, + 3, 1039, 519, 0, 3397, 3398, 3, 1033, 516, 0, 3398, 3399, 3, 1021, 510, + 0, 3399, 3400, 3, 1037, 518, 0, 3400, 494, 1, 0, 0, 0, 3401, 3402, 3, 1045, + 522, 0, 3402, 3403, 3, 1043, 521, 0, 3403, 3404, 3, 1021, 510, 0, 3404, + 3405, 3, 1031, 515, 0, 3405, 3406, 3, 1017, 508, 0, 3406, 3407, 3, 1043, + 521, 0, 3407, 3408, 3, 1029, 514, 0, 3408, 3409, 3, 1025, 512, 0, 3409, + 496, 1, 0, 0, 0, 3410, 3411, 3, 1055, 527, 0, 3411, 3412, 3, 1017, 508, + 0, 3412, 3413, 3, 1019, 509, 0, 3413, 3414, 3, 1033, 516, 0, 3414, 3415, + 3, 1043, 521, 0, 3415, 3416, 3, 1023, 511, 0, 3416, 3417, 3, 1025, 512, + 0, 3417, 3418, 3, 1063, 531, 0, 3418, 498, 1, 0, 0, 0, 3419, 3420, 3, 1031, + 515, 0, 3420, 3421, 5, 49, 0, 0, 3421, 500, 1, 0, 0, 0, 3422, 3423, 3, + 1031, 515, 0, 3423, 3424, 5, 50, 0, 0, 3424, 502, 1, 0, 0, 0, 3425, 3426, + 3, 1031, 515, 0, 3426, 3427, 5, 51, 0, 0, 3427, 504, 1, 0, 0, 0, 3428, + 3429, 3, 1031, 515, 0, 3429, 3430, 5, 52, 0, 0, 3430, 506, 1, 0, 0, 0, + 3431, 3432, 3, 1031, 515, 0, 3432, 3433, 5, 53, 0, 0, 3433, 508, 1, 0, + 0, 0, 3434, 3435, 3, 1031, 515, 0, 3435, 3436, 5, 54, 0, 0, 3436, 510, + 1, 0, 0, 0, 3437, 3438, 3, 1047, 523, 0, 3438, 3439, 3, 1017, 508, 0, 3439, + 3440, 3, 1051, 525, 0, 3440, 3441, 3, 1017, 508, 0, 3441, 3442, 3, 1029, + 514, 0, 3442, 3443, 3, 1051, 525, 0, 3443, 3444, 3, 1017, 508, 0, 3444, + 3445, 3, 1047, 523, 0, 3445, 3446, 3, 1031, 515, 0, 3446, 512, 1, 0, 0, + 0, 3447, 3448, 3, 1053, 526, 0, 3448, 3449, 3, 1055, 527, 0, 3449, 3450, + 3, 1051, 525, 0, 3450, 3451, 3, 1033, 516, 0, 3451, 3452, 3, 1043, 521, + 0, 3452, 3453, 3, 1029, 514, 0, 3453, 514, 1, 0, 0, 0, 3454, 3455, 3, 1033, + 516, 0, 3455, 3456, 3, 1043, 521, 0, 3456, 3457, 3, 1055, 527, 0, 3457, + 3458, 3, 1025, 512, 0, 3458, 3459, 3, 1029, 514, 0, 3459, 3460, 3, 1025, + 512, 0, 3460, 3461, 3, 1051, 525, 0, 3461, 516, 1, 0, 0, 0, 3462, 3463, + 3, 1039, 519, 0, 3463, 3464, 3, 1045, 522, 0, 3464, 3465, 3, 1043, 521, + 0, 3465, 3466, 3, 1029, 514, 0, 3466, 518, 1, 0, 0, 0, 3467, 3468, 3, 1023, + 511, 0, 3468, 3469, 3, 1025, 512, 0, 3469, 3470, 3, 1021, 510, 0, 3470, + 3471, 3, 1033, 516, 0, 3471, 3472, 3, 1041, 520, 0, 3472, 3473, 3, 1017, + 508, 0, 3473, 3474, 3, 1039, 519, 0, 3474, 520, 1, 0, 0, 0, 3475, 3476, + 3, 1019, 509, 0, 3476, 3477, 3, 1045, 522, 0, 3477, 3478, 3, 1045, 522, + 0, 3478, 3479, 3, 1039, 519, 0, 3479, 3480, 3, 1025, 512, 0, 3480, 3481, + 3, 1017, 508, 0, 3481, 3482, 3, 1043, 521, 0, 3482, 522, 1, 0, 0, 0, 3483, + 3484, 3, 1023, 511, 0, 3484, 3485, 3, 1017, 508, 0, 3485, 3486, 3, 1055, + 527, 0, 3486, 3487, 3, 1025, 512, 0, 3487, 3488, 3, 1055, 527, 0, 3488, + 3489, 3, 1033, 516, 0, 3489, 3490, 3, 1041, 520, 0, 3490, 3491, 3, 1025, + 512, 0, 3491, 524, 1, 0, 0, 0, 3492, 3493, 3, 1023, 511, 0, 3493, 3494, + 3, 1017, 508, 0, 3494, 3495, 3, 1055, 527, 0, 3495, 3496, 3, 1025, 512, + 0, 3496, 526, 1, 0, 0, 0, 3497, 3498, 3, 1017, 508, 0, 3498, 3499, 3, 1057, + 528, 0, 3499, 3500, 3, 1055, 527, 0, 3500, 3501, 3, 1045, 522, 0, 3501, + 3502, 3, 1043, 521, 0, 3502, 3503, 3, 1057, 528, 0, 3503, 3504, 3, 1041, + 520, 0, 3504, 3505, 3, 1019, 509, 0, 3505, 3506, 3, 1025, 512, 0, 3506, + 3507, 3, 1051, 525, 0, 3507, 528, 1, 0, 0, 0, 3508, 3509, 3, 1019, 509, + 0, 3509, 3510, 3, 1033, 516, 0, 3510, 3511, 3, 1043, 521, 0, 3511, 3512, + 3, 1017, 508, 0, 3512, 3513, 3, 1051, 525, 0, 3513, 3514, 3, 1065, 532, + 0, 3514, 530, 1, 0, 0, 0, 3515, 3516, 3, 1031, 515, 0, 3516, 3517, 3, 1017, + 508, 0, 3517, 3518, 3, 1053, 526, 0, 3518, 3519, 3, 1031, 515, 0, 3519, + 3520, 3, 1025, 512, 0, 3520, 3521, 3, 1023, 511, 0, 3521, 3522, 3, 1053, + 526, 0, 3522, 3523, 3, 1055, 527, 0, 3523, 3524, 3, 1051, 525, 0, 3524, + 3525, 3, 1033, 516, 0, 3525, 3526, 3, 1043, 521, 0, 3526, 3527, 3, 1029, + 514, 0, 3527, 532, 1, 0, 0, 0, 3528, 3529, 3, 1021, 510, 0, 3529, 3530, + 3, 1057, 528, 0, 3530, 3531, 3, 1051, 525, 0, 3531, 3532, 3, 1051, 525, + 0, 3532, 3533, 3, 1025, 512, 0, 3533, 3534, 3, 1043, 521, 0, 3534, 3535, + 3, 1021, 510, 0, 3535, 3536, 3, 1065, 532, 0, 3536, 534, 1, 0, 0, 0, 3537, + 3538, 3, 1027, 513, 0, 3538, 3539, 3, 1039, 519, 0, 3539, 3540, 3, 1045, + 522, 0, 3540, 3541, 3, 1017, 508, 0, 3541, 3542, 3, 1055, 527, 0, 3542, + 536, 1, 0, 0, 0, 3543, 3544, 3, 1053, 526, 0, 3544, 3545, 3, 1055, 527, + 0, 3545, 3546, 3, 1051, 525, 0, 3546, 3547, 3, 1033, 516, 0, 3547, 3548, + 3, 1043, 521, 0, 3548, 3549, 3, 1029, 514, 0, 3549, 3550, 3, 1055, 527, + 0, 3550, 3551, 3, 1025, 512, 0, 3551, 3552, 3, 1041, 520, 0, 3552, 3553, + 3, 1047, 523, 0, 3553, 3554, 3, 1039, 519, 0, 3554, 3555, 3, 1017, 508, + 0, 3555, 3556, 3, 1055, 527, 0, 3556, 3557, 3, 1025, 512, 0, 3557, 538, + 1, 0, 0, 0, 3558, 3559, 3, 1025, 512, 0, 3559, 3560, 3, 1043, 521, 0, 3560, + 3561, 3, 1057, 528, 0, 3561, 3562, 3, 1041, 520, 0, 3562, 540, 1, 0, 0, + 0, 3563, 3564, 3, 1021, 510, 0, 3564, 3565, 3, 1045, 522, 0, 3565, 3566, + 3, 1057, 528, 0, 3566, 3567, 3, 1043, 521, 0, 3567, 3568, 3, 1055, 527, + 0, 3568, 542, 1, 0, 0, 0, 3569, 3570, 3, 1053, 526, 0, 3570, 3571, 3, 1057, + 528, 0, 3571, 3572, 3, 1041, 520, 0, 3572, 544, 1, 0, 0, 0, 3573, 3574, + 3, 1017, 508, 0, 3574, 3575, 3, 1059, 529, 0, 3575, 3576, 3, 1029, 514, + 0, 3576, 546, 1, 0, 0, 0, 3577, 3578, 3, 1041, 520, 0, 3578, 3579, 3, 1033, + 516, 0, 3579, 3580, 3, 1043, 521, 0, 3580, 548, 1, 0, 0, 0, 3581, 3582, + 3, 1041, 520, 0, 3582, 3583, 3, 1017, 508, 0, 3583, 3584, 3, 1063, 531, + 0, 3584, 550, 1, 0, 0, 0, 3585, 3586, 3, 1039, 519, 0, 3586, 3587, 3, 1025, + 512, 0, 3587, 3588, 3, 1043, 521, 0, 3588, 3589, 3, 1029, 514, 0, 3589, + 3590, 3, 1055, 527, 0, 3590, 3591, 3, 1031, 515, 0, 3591, 552, 1, 0, 0, + 0, 3592, 3593, 3, 1055, 527, 0, 3593, 3594, 3, 1051, 525, 0, 3594, 3595, + 3, 1033, 516, 0, 3595, 3596, 3, 1041, 520, 0, 3596, 554, 1, 0, 0, 0, 3597, + 3598, 3, 1021, 510, 0, 3598, 3599, 3, 1045, 522, 0, 3599, 3600, 3, 1017, + 508, 0, 3600, 3601, 3, 1039, 519, 0, 3601, 3602, 3, 1025, 512, 0, 3602, + 3603, 3, 1053, 526, 0, 3603, 3604, 3, 1021, 510, 0, 3604, 3605, 3, 1025, + 512, 0, 3605, 556, 1, 0, 0, 0, 3606, 3607, 3, 1021, 510, 0, 3607, 3608, + 3, 1017, 508, 0, 3608, 3609, 3, 1053, 526, 0, 3609, 3610, 3, 1055, 527, + 0, 3610, 558, 1, 0, 0, 0, 3611, 3612, 3, 1017, 508, 0, 3612, 3613, 3, 1043, + 521, 0, 3613, 3614, 3, 1023, 511, 0, 3614, 560, 1, 0, 0, 0, 3615, 3616, + 3, 1045, 522, 0, 3616, 3617, 3, 1051, 525, 0, 3617, 562, 1, 0, 0, 0, 3618, + 3619, 3, 1043, 521, 0, 3619, 3620, 3, 1045, 522, 0, 3620, 3621, 3, 1055, + 527, 0, 3621, 564, 1, 0, 0, 0, 3622, 3623, 3, 1043, 521, 0, 3623, 3624, + 3, 1057, 528, 0, 3624, 3625, 3, 1039, 519, 0, 3625, 3626, 3, 1039, 519, + 0, 3626, 566, 1, 0, 0, 0, 3627, 3628, 3, 1033, 516, 0, 3628, 3629, 3, 1043, + 521, 0, 3629, 568, 1, 0, 0, 0, 3630, 3631, 3, 1019, 509, 0, 3631, 3632, + 3, 1025, 512, 0, 3632, 3633, 3, 1055, 527, 0, 3633, 3634, 3, 1061, 530, + 0, 3634, 3635, 3, 1025, 512, 0, 3635, 3636, 3, 1025, 512, 0, 3636, 3637, + 3, 1043, 521, 0, 3637, 570, 1, 0, 0, 0, 3638, 3639, 3, 1039, 519, 0, 3639, + 3640, 3, 1033, 516, 0, 3640, 3641, 3, 1037, 518, 0, 3641, 3642, 3, 1025, + 512, 0, 3642, 572, 1, 0, 0, 0, 3643, 3644, 3, 1041, 520, 0, 3644, 3645, + 3, 1017, 508, 0, 3645, 3646, 3, 1055, 527, 0, 3646, 3647, 3, 1021, 510, + 0, 3647, 3648, 3, 1031, 515, 0, 3648, 574, 1, 0, 0, 0, 3649, 3650, 3, 1025, + 512, 0, 3650, 3651, 3, 1063, 531, 0, 3651, 3652, 3, 1033, 516, 0, 3652, + 3653, 3, 1053, 526, 0, 3653, 3654, 3, 1055, 527, 0, 3654, 3655, 3, 1053, + 526, 0, 3655, 576, 1, 0, 0, 0, 3656, 3657, 3, 1057, 528, 0, 3657, 3658, + 3, 1043, 521, 0, 3658, 3659, 3, 1033, 516, 0, 3659, 3660, 3, 1049, 524, + 0, 3660, 3661, 3, 1057, 528, 0, 3661, 3662, 3, 1025, 512, 0, 3662, 578, + 1, 0, 0, 0, 3663, 3664, 3, 1023, 511, 0, 3664, 3665, 3, 1025, 512, 0, 3665, + 3666, 3, 1027, 513, 0, 3666, 3667, 3, 1017, 508, 0, 3667, 3668, 3, 1057, + 528, 0, 3668, 3669, 3, 1039, 519, 0, 3669, 3670, 3, 1055, 527, 0, 3670, + 580, 1, 0, 0, 0, 3671, 3672, 3, 1055, 527, 0, 3672, 3673, 3, 1051, 525, + 0, 3673, 3674, 3, 1057, 528, 0, 3674, 3675, 3, 1025, 512, 0, 3675, 582, + 1, 0, 0, 0, 3676, 3677, 3, 1027, 513, 0, 3677, 3678, 3, 1017, 508, 0, 3678, + 3679, 3, 1039, 519, 0, 3679, 3680, 3, 1053, 526, 0, 3680, 3681, 3, 1025, + 512, 0, 3681, 584, 1, 0, 0, 0, 3682, 3683, 3, 1059, 529, 0, 3683, 3684, + 3, 1017, 508, 0, 3684, 3685, 3, 1039, 519, 0, 3685, 3686, 3, 1033, 516, + 0, 3686, 3687, 3, 1023, 511, 0, 3687, 3688, 3, 1017, 508, 0, 3688, 3689, + 3, 1055, 527, 0, 3689, 3690, 3, 1033, 516, 0, 3690, 3691, 3, 1045, 522, + 0, 3691, 3692, 3, 1043, 521, 0, 3692, 586, 1, 0, 0, 0, 3693, 3694, 3, 1027, + 513, 0, 3694, 3695, 3, 1025, 512, 0, 3695, 3696, 3, 1025, 512, 0, 3696, + 3697, 3, 1023, 511, 0, 3697, 3698, 3, 1019, 509, 0, 3698, 3699, 3, 1017, + 508, 0, 3699, 3700, 3, 1021, 510, 0, 3700, 3701, 3, 1037, 518, 0, 3701, + 588, 1, 0, 0, 0, 3702, 3703, 3, 1051, 525, 0, 3703, 3704, 3, 1057, 528, + 0, 3704, 3705, 3, 1039, 519, 0, 3705, 3706, 3, 1025, 512, 0, 3706, 590, + 1, 0, 0, 0, 3707, 3708, 3, 1051, 525, 0, 3708, 3709, 3, 1025, 512, 0, 3709, + 3710, 3, 1049, 524, 0, 3710, 3711, 3, 1057, 528, 0, 3711, 3712, 3, 1033, + 516, 0, 3712, 3713, 3, 1051, 525, 0, 3713, 3714, 3, 1025, 512, 0, 3714, + 3715, 3, 1023, 511, 0, 3715, 592, 1, 0, 0, 0, 3716, 3717, 3, 1025, 512, + 0, 3717, 3718, 3, 1051, 525, 0, 3718, 3719, 3, 1051, 525, 0, 3719, 3720, + 3, 1045, 522, 0, 3720, 3721, 3, 1051, 525, 0, 3721, 594, 1, 0, 0, 0, 3722, + 3723, 3, 1051, 525, 0, 3723, 3724, 3, 1017, 508, 0, 3724, 3725, 3, 1033, + 516, 0, 3725, 3726, 3, 1053, 526, 0, 3726, 3727, 3, 1025, 512, 0, 3727, + 596, 1, 0, 0, 0, 3728, 3729, 3, 1051, 525, 0, 3729, 3730, 3, 1017, 508, + 0, 3730, 3731, 3, 1043, 521, 0, 3731, 3732, 3, 1029, 514, 0, 3732, 3733, + 3, 1025, 512, 0, 3733, 598, 1, 0, 0, 0, 3734, 3735, 3, 1051, 525, 0, 3735, + 3736, 3, 1025, 512, 0, 3736, 3737, 3, 1029, 514, 0, 3737, 3738, 3, 1025, + 512, 0, 3738, 3739, 3, 1063, 531, 0, 3739, 600, 1, 0, 0, 0, 3740, 3741, + 3, 1047, 523, 0, 3741, 3742, 3, 1017, 508, 0, 3742, 3743, 3, 1055, 527, + 0, 3743, 3744, 3, 1055, 527, 0, 3744, 3745, 3, 1025, 512, 0, 3745, 3746, + 3, 1051, 525, 0, 3746, 3747, 3, 1043, 521, 0, 3747, 602, 1, 0, 0, 0, 3748, + 3749, 3, 1025, 512, 0, 3749, 3750, 3, 1063, 531, 0, 3750, 3751, 3, 1047, + 523, 0, 3751, 3752, 3, 1051, 525, 0, 3752, 3753, 3, 1025, 512, 0, 3753, + 3754, 3, 1053, 526, 0, 3754, 3755, 3, 1053, 526, 0, 3755, 3756, 3, 1033, + 516, 0, 3756, 3757, 3, 1045, 522, 0, 3757, 3758, 3, 1043, 521, 0, 3758, + 604, 1, 0, 0, 0, 3759, 3760, 3, 1063, 531, 0, 3760, 3761, 3, 1047, 523, + 0, 3761, 3762, 3, 1017, 508, 0, 3762, 3763, 3, 1055, 527, 0, 3763, 3764, + 3, 1031, 515, 0, 3764, 606, 1, 0, 0, 0, 3765, 3766, 3, 1021, 510, 0, 3766, + 3767, 3, 1045, 522, 0, 3767, 3768, 3, 1043, 521, 0, 3768, 3769, 3, 1053, + 526, 0, 3769, 3770, 3, 1055, 527, 0, 3770, 3771, 3, 1051, 525, 0, 3771, + 3772, 3, 1017, 508, 0, 3772, 3773, 3, 1033, 516, 0, 3773, 3774, 3, 1043, + 521, 0, 3774, 3775, 3, 1055, 527, 0, 3775, 608, 1, 0, 0, 0, 3776, 3777, + 3, 1021, 510, 0, 3777, 3778, 3, 1017, 508, 0, 3778, 3779, 3, 1039, 519, + 0, 3779, 3780, 3, 1021, 510, 0, 3780, 3781, 3, 1057, 528, 0, 3781, 3782, + 3, 1039, 519, 0, 3782, 3783, 3, 1017, 508, 0, 3783, 3784, 3, 1055, 527, + 0, 3784, 3785, 3, 1025, 512, 0, 3785, 3786, 3, 1023, 511, 0, 3786, 610, + 1, 0, 0, 0, 3787, 3788, 3, 1051, 525, 0, 3788, 3789, 3, 1025, 512, 0, 3789, + 3790, 3, 1053, 526, 0, 3790, 3791, 3, 1055, 527, 0, 3791, 612, 1, 0, 0, + 0, 3792, 3793, 3, 1053, 526, 0, 3793, 3794, 3, 1025, 512, 0, 3794, 3795, + 3, 1051, 525, 0, 3795, 3796, 3, 1059, 529, 0, 3796, 3797, 3, 1033, 516, + 0, 3797, 3798, 3, 1021, 510, 0, 3798, 3799, 3, 1025, 512, 0, 3799, 614, + 1, 0, 0, 0, 3800, 3801, 3, 1053, 526, 0, 3801, 3802, 3, 1025, 512, 0, 3802, + 3803, 3, 1051, 525, 0, 3803, 3804, 3, 1059, 529, 0, 3804, 3805, 3, 1033, + 516, 0, 3805, 3806, 3, 1021, 510, 0, 3806, 3807, 3, 1025, 512, 0, 3807, + 3808, 3, 1053, 526, 0, 3808, 616, 1, 0, 0, 0, 3809, 3810, 3, 1045, 522, + 0, 3810, 3811, 3, 1023, 511, 0, 3811, 3812, 3, 1017, 508, 0, 3812, 3813, + 3, 1055, 527, 0, 3813, 3814, 3, 1017, 508, 0, 3814, 618, 1, 0, 0, 0, 3815, + 3816, 3, 1019, 509, 0, 3816, 3817, 3, 1017, 508, 0, 3817, 3818, 3, 1053, + 526, 0, 3818, 3819, 3, 1025, 512, 0, 3819, 620, 1, 0, 0, 0, 3820, 3821, + 3, 1017, 508, 0, 3821, 3822, 3, 1057, 528, 0, 3822, 3823, 3, 1055, 527, + 0, 3823, 3824, 3, 1031, 515, 0, 3824, 622, 1, 0, 0, 0, 3825, 3826, 3, 1017, + 508, 0, 3826, 3827, 3, 1057, 528, 0, 3827, 3828, 3, 1055, 527, 0, 3828, + 3829, 3, 1031, 515, 0, 3829, 3830, 3, 1025, 512, 0, 3830, 3831, 3, 1043, + 521, 0, 3831, 3832, 3, 1055, 527, 0, 3832, 3833, 3, 1033, 516, 0, 3833, + 3834, 3, 1021, 510, 0, 3834, 3835, 3, 1017, 508, 0, 3835, 3836, 3, 1055, + 527, 0, 3836, 3837, 3, 1033, 516, 0, 3837, 3838, 3, 1045, 522, 0, 3838, + 3839, 3, 1043, 521, 0, 3839, 624, 1, 0, 0, 0, 3840, 3841, 3, 1019, 509, + 0, 3841, 3842, 3, 1017, 508, 0, 3842, 3843, 3, 1053, 526, 0, 3843, 3844, + 3, 1033, 516, 0, 3844, 3845, 3, 1021, 510, 0, 3845, 626, 1, 0, 0, 0, 3846, + 3847, 3, 1043, 521, 0, 3847, 3848, 3, 1045, 522, 0, 3848, 3849, 3, 1055, + 527, 0, 3849, 3850, 3, 1031, 515, 0, 3850, 3851, 3, 1033, 516, 0, 3851, + 3852, 3, 1043, 521, 0, 3852, 3853, 3, 1029, 514, 0, 3853, 628, 1, 0, 0, + 0, 3854, 3855, 3, 1045, 522, 0, 3855, 3856, 3, 1017, 508, 0, 3856, 3857, + 3, 1057, 528, 0, 3857, 3858, 3, 1055, 527, 0, 3858, 3859, 3, 1031, 515, + 0, 3859, 630, 1, 0, 0, 0, 3860, 3861, 3, 1045, 522, 0, 3861, 3862, 3, 1047, + 523, 0, 3862, 3863, 3, 1025, 512, 0, 3863, 3864, 3, 1051, 525, 0, 3864, + 3865, 3, 1017, 508, 0, 3865, 3866, 3, 1055, 527, 0, 3866, 3867, 3, 1033, + 516, 0, 3867, 3868, 3, 1045, 522, 0, 3868, 3869, 3, 1043, 521, 0, 3869, + 632, 1, 0, 0, 0, 3870, 3871, 3, 1041, 520, 0, 3871, 3872, 3, 1025, 512, + 0, 3872, 3873, 3, 1055, 527, 0, 3873, 3874, 3, 1031, 515, 0, 3874, 3875, + 3, 1045, 522, 0, 3875, 3876, 3, 1023, 511, 0, 3876, 634, 1, 0, 0, 0, 3877, + 3878, 3, 1047, 523, 0, 3878, 3879, 3, 1017, 508, 0, 3879, 3880, 3, 1055, + 527, 0, 3880, 3881, 3, 1031, 515, 0, 3881, 636, 1, 0, 0, 0, 3882, 3883, + 3, 1055, 527, 0, 3883, 3884, 3, 1033, 516, 0, 3884, 3885, 3, 1041, 520, + 0, 3885, 3886, 3, 1025, 512, 0, 3886, 3887, 3, 1045, 522, 0, 3887, 3888, + 3, 1057, 528, 0, 3888, 3889, 3, 1055, 527, 0, 3889, 638, 1, 0, 0, 0, 3890, + 3891, 3, 1019, 509, 0, 3891, 3892, 3, 1045, 522, 0, 3892, 3893, 3, 1023, + 511, 0, 3893, 3894, 3, 1065, 532, 0, 3894, 640, 1, 0, 0, 0, 3895, 3896, + 3, 1051, 525, 0, 3896, 3897, 3, 1025, 512, 0, 3897, 3898, 3, 1053, 526, + 0, 3898, 3899, 3, 1047, 523, 0, 3899, 3900, 3, 1045, 522, 0, 3900, 3901, + 3, 1043, 521, 0, 3901, 3902, 3, 1053, 526, 0, 3902, 3903, 3, 1025, 512, + 0, 3903, 642, 1, 0, 0, 0, 3904, 3905, 3, 1051, 525, 0, 3905, 3906, 3, 1025, + 512, 0, 3906, 3907, 3, 1049, 524, 0, 3907, 3908, 3, 1057, 528, 0, 3908, + 3909, 3, 1025, 512, 0, 3909, 3910, 3, 1053, 526, 0, 3910, 3911, 3, 1055, + 527, 0, 3911, 644, 1, 0, 0, 0, 3912, 3913, 3, 1035, 517, 0, 3913, 3914, + 3, 1053, 526, 0, 3914, 3915, 3, 1045, 522, 0, 3915, 3916, 3, 1043, 521, + 0, 3916, 646, 1, 0, 0, 0, 3917, 3918, 3, 1063, 531, 0, 3918, 3919, 3, 1041, + 520, 0, 3919, 3920, 3, 1039, 519, 0, 3920, 648, 1, 0, 0, 0, 3921, 3922, + 3, 1053, 526, 0, 3922, 3923, 3, 1055, 527, 0, 3923, 3924, 3, 1017, 508, + 0, 3924, 3925, 3, 1055, 527, 0, 3925, 3926, 3, 1057, 528, 0, 3926, 3927, + 3, 1053, 526, 0, 3927, 650, 1, 0, 0, 0, 3928, 3929, 3, 1059, 529, 0, 3929, + 3930, 3, 1025, 512, 0, 3930, 3931, 3, 1051, 525, 0, 3931, 3932, 3, 1053, + 526, 0, 3932, 3933, 3, 1033, 516, 0, 3933, 3934, 3, 1045, 522, 0, 3934, + 3935, 3, 1043, 521, 0, 3935, 652, 1, 0, 0, 0, 3936, 3937, 3, 1029, 514, + 0, 3937, 3938, 3, 1025, 512, 0, 3938, 3939, 3, 1055, 527, 0, 3939, 654, + 1, 0, 0, 0, 3940, 3941, 3, 1047, 523, 0, 3941, 3942, 3, 1045, 522, 0, 3942, + 3943, 3, 1053, 526, 0, 3943, 3944, 3, 1055, 527, 0, 3944, 656, 1, 0, 0, + 0, 3945, 3946, 3, 1047, 523, 0, 3946, 3947, 3, 1057, 528, 0, 3947, 3948, + 3, 1055, 527, 0, 3948, 658, 1, 0, 0, 0, 3949, 3950, 3, 1047, 523, 0, 3950, + 3951, 3, 1017, 508, 0, 3951, 3952, 3, 1055, 527, 0, 3952, 3953, 3, 1021, + 510, 0, 3953, 3954, 3, 1031, 515, 0, 3954, 660, 1, 0, 0, 0, 3955, 3956, + 3, 1017, 508, 0, 3956, 3957, 3, 1047, 523, 0, 3957, 3958, 3, 1033, 516, + 0, 3958, 662, 1, 0, 0, 0, 3959, 3960, 3, 1021, 510, 0, 3960, 3961, 3, 1039, + 519, 0, 3961, 3962, 3, 1033, 516, 0, 3962, 3963, 3, 1025, 512, 0, 3963, + 3964, 3, 1043, 521, 0, 3964, 3965, 3, 1055, 527, 0, 3965, 664, 1, 0, 0, + 0, 3966, 3967, 3, 1021, 510, 0, 3967, 3968, 3, 1039, 519, 0, 3968, 3969, + 3, 1033, 516, 0, 3969, 3970, 3, 1025, 512, 0, 3970, 3971, 3, 1043, 521, + 0, 3971, 3972, 3, 1055, 527, 0, 3972, 3973, 3, 1053, 526, 0, 3973, 666, + 1, 0, 0, 0, 3974, 3975, 3, 1047, 523, 0, 3975, 3976, 3, 1057, 528, 0, 3976, + 3977, 3, 1019, 509, 0, 3977, 3978, 3, 1039, 519, 0, 3978, 3979, 3, 1033, + 516, 0, 3979, 3980, 3, 1053, 526, 0, 3980, 3981, 3, 1031, 515, 0, 3981, + 668, 1, 0, 0, 0, 3982, 3983, 3, 1025, 512, 0, 3983, 3984, 3, 1063, 531, + 0, 3984, 3985, 3, 1047, 523, 0, 3985, 3986, 3, 1045, 522, 0, 3986, 3987, + 3, 1053, 526, 0, 3987, 3988, 3, 1025, 512, 0, 3988, 670, 1, 0, 0, 0, 3989, + 3990, 3, 1043, 521, 0, 3990, 3991, 3, 1017, 508, 0, 3991, 3992, 3, 1041, + 520, 0, 3992, 3993, 3, 1025, 512, 0, 3993, 3994, 3, 1053, 526, 0, 3994, + 3995, 3, 1047, 523, 0, 3995, 3996, 3, 1017, 508, 0, 3996, 3997, 3, 1021, + 510, 0, 3997, 3998, 3, 1025, 512, 0, 3998, 672, 1, 0, 0, 0, 3999, 4000, + 3, 1053, 526, 0, 4000, 4001, 3, 1025, 512, 0, 4001, 4002, 3, 1053, 526, + 0, 4002, 4003, 3, 1053, 526, 0, 4003, 4004, 3, 1033, 516, 0, 4004, 4005, + 3, 1045, 522, 0, 4005, 4006, 3, 1043, 521, 0, 4006, 674, 1, 0, 0, 0, 4007, + 4008, 3, 1029, 514, 0, 4008, 4009, 3, 1057, 528, 0, 4009, 4010, 3, 1025, + 512, 0, 4010, 4011, 3, 1053, 526, 0, 4011, 4012, 3, 1055, 527, 0, 4012, + 676, 1, 0, 0, 0, 4013, 4014, 3, 1047, 523, 0, 4014, 4015, 3, 1017, 508, + 0, 4015, 4016, 3, 1029, 514, 0, 4016, 4017, 3, 1033, 516, 0, 4017, 4018, + 3, 1043, 521, 0, 4018, 4019, 3, 1029, 514, 0, 4019, 678, 1, 0, 0, 0, 4020, + 4021, 3, 1043, 521, 0, 4021, 4022, 3, 1045, 522, 0, 4022, 4023, 3, 1055, + 527, 0, 4023, 4024, 5, 95, 0, 0, 4024, 4025, 3, 1053, 526, 0, 4025, 4026, + 3, 1057, 528, 0, 4026, 4027, 3, 1047, 523, 0, 4027, 4028, 3, 1047, 523, + 0, 4028, 4029, 3, 1045, 522, 0, 4029, 4030, 3, 1051, 525, 0, 4030, 4031, + 3, 1055, 527, 0, 4031, 4032, 3, 1025, 512, 0, 4032, 4033, 3, 1023, 511, + 0, 4033, 680, 1, 0, 0, 0, 4034, 4035, 3, 1057, 528, 0, 4035, 4036, 3, 1053, + 526, 0, 4036, 4037, 3, 1025, 512, 0, 4037, 4038, 3, 1051, 525, 0, 4038, + 4039, 3, 1043, 521, 0, 4039, 4040, 3, 1017, 508, 0, 4040, 4041, 3, 1041, + 520, 0, 4041, 4042, 3, 1025, 512, 0, 4042, 682, 1, 0, 0, 0, 4043, 4044, + 3, 1047, 523, 0, 4044, 4045, 3, 1017, 508, 0, 4045, 4046, 3, 1053, 526, + 0, 4046, 4047, 3, 1053, 526, 0, 4047, 4048, 3, 1061, 530, 0, 4048, 4049, + 3, 1045, 522, 0, 4049, 4050, 3, 1051, 525, 0, 4050, 4051, 3, 1023, 511, + 0, 4051, 684, 1, 0, 0, 0, 4052, 4053, 3, 1021, 510, 0, 4053, 4054, 3, 1045, + 522, 0, 4054, 4055, 3, 1043, 521, 0, 4055, 4056, 3, 1043, 521, 0, 4056, + 4057, 3, 1025, 512, 0, 4057, 4058, 3, 1021, 510, 0, 4058, 4059, 3, 1055, + 527, 0, 4059, 4060, 3, 1033, 516, 0, 4060, 4061, 3, 1045, 522, 0, 4061, + 4062, 3, 1043, 521, 0, 4062, 686, 1, 0, 0, 0, 4063, 4064, 3, 1023, 511, + 0, 4064, 4065, 3, 1017, 508, 0, 4065, 4066, 3, 1055, 527, 0, 4066, 4067, + 3, 1017, 508, 0, 4067, 4068, 3, 1019, 509, 0, 4068, 4069, 3, 1017, 508, + 0, 4069, 4070, 3, 1053, 526, 0, 4070, 4071, 3, 1025, 512, 0, 4071, 688, + 1, 0, 0, 0, 4072, 4073, 3, 1049, 524, 0, 4073, 4074, 3, 1057, 528, 0, 4074, + 4075, 3, 1025, 512, 0, 4075, 4076, 3, 1051, 525, 0, 4076, 4077, 3, 1065, + 532, 0, 4077, 690, 1, 0, 0, 0, 4078, 4079, 3, 1041, 520, 0, 4079, 4080, + 3, 1017, 508, 0, 4080, 4081, 3, 1047, 523, 0, 4081, 692, 1, 0, 0, 0, 4082, + 4083, 3, 1041, 520, 0, 4083, 4084, 3, 1017, 508, 0, 4084, 4085, 3, 1047, + 523, 0, 4085, 4086, 3, 1047, 523, 0, 4086, 4087, 3, 1033, 516, 0, 4087, + 4088, 3, 1043, 521, 0, 4088, 4089, 3, 1029, 514, 0, 4089, 694, 1, 0, 0, + 0, 4090, 4091, 3, 1033, 516, 0, 4091, 4092, 3, 1041, 520, 0, 4092, 4093, + 3, 1047, 523, 0, 4093, 4094, 3, 1045, 522, 0, 4094, 4095, 3, 1051, 525, + 0, 4095, 4096, 3, 1055, 527, 0, 4096, 696, 1, 0, 0, 0, 4097, 4098, 3, 1033, + 516, 0, 4098, 4099, 3, 1043, 521, 0, 4099, 4100, 3, 1055, 527, 0, 4100, + 4101, 3, 1045, 522, 0, 4101, 698, 1, 0, 0, 0, 4102, 4103, 3, 1019, 509, + 0, 4103, 4104, 3, 1017, 508, 0, 4104, 4105, 3, 1055, 527, 0, 4105, 4106, + 3, 1021, 510, 0, 4106, 4107, 3, 1031, 515, 0, 4107, 700, 1, 0, 0, 0, 4108, + 4109, 3, 1039, 519, 0, 4109, 4110, 3, 1033, 516, 0, 4110, 4111, 3, 1043, + 521, 0, 4111, 4112, 3, 1037, 518, 0, 4112, 702, 1, 0, 0, 0, 4113, 4114, + 3, 1025, 512, 0, 4114, 4115, 3, 1063, 531, 0, 4115, 4116, 3, 1047, 523, + 0, 4116, 4117, 3, 1045, 522, 0, 4117, 4118, 3, 1051, 525, 0, 4118, 4119, + 3, 1055, 527, 0, 4119, 704, 1, 0, 0, 0, 4120, 4121, 3, 1029, 514, 0, 4121, + 4122, 3, 1025, 512, 0, 4122, 4123, 3, 1043, 521, 0, 4123, 4124, 3, 1025, + 512, 0, 4124, 4125, 3, 1051, 525, 0, 4125, 4126, 3, 1017, 508, 0, 4126, + 4127, 3, 1055, 527, 0, 4127, 4128, 3, 1025, 512, 0, 4128, 706, 1, 0, 0, + 0, 4129, 4130, 3, 1021, 510, 0, 4130, 4131, 3, 1045, 522, 0, 4131, 4132, + 3, 1043, 521, 0, 4132, 4133, 3, 1043, 521, 0, 4133, 4134, 3, 1025, 512, + 0, 4134, 4135, 3, 1021, 510, 0, 4135, 4136, 3, 1055, 527, 0, 4136, 4137, + 3, 1045, 522, 0, 4137, 4138, 3, 1051, 525, 0, 4138, 708, 1, 0, 0, 0, 4139, + 4140, 3, 1025, 512, 0, 4140, 4141, 3, 1063, 531, 0, 4141, 4142, 3, 1025, + 512, 0, 4142, 4143, 3, 1021, 510, 0, 4143, 710, 1, 0, 0, 0, 4144, 4145, + 3, 1055, 527, 0, 4145, 4146, 3, 1017, 508, 0, 4146, 4147, 3, 1019, 509, + 0, 4147, 4148, 3, 1039, 519, 0, 4148, 4149, 3, 1025, 512, 0, 4149, 4150, + 3, 1053, 526, 0, 4150, 712, 1, 0, 0, 0, 4151, 4152, 3, 1059, 529, 0, 4152, + 4153, 3, 1033, 516, 0, 4153, 4154, 3, 1025, 512, 0, 4154, 4155, 3, 1061, + 530, 0, 4155, 4156, 3, 1053, 526, 0, 4156, 714, 1, 0, 0, 0, 4157, 4158, + 3, 1025, 512, 0, 4158, 4159, 3, 1063, 531, 0, 4159, 4160, 3, 1047, 523, + 0, 4160, 4161, 3, 1045, 522, 0, 4161, 4162, 3, 1053, 526, 0, 4162, 4163, + 3, 1025, 512, 0, 4163, 4164, 3, 1023, 511, 0, 4164, 716, 1, 0, 0, 0, 4165, + 4166, 3, 1047, 523, 0, 4166, 4167, 3, 1017, 508, 0, 4167, 4168, 3, 1051, + 525, 0, 4168, 4169, 3, 1017, 508, 0, 4169, 4170, 3, 1041, 520, 0, 4170, + 4171, 3, 1025, 512, 0, 4171, 4172, 3, 1055, 527, 0, 4172, 4173, 3, 1025, + 512, 0, 4173, 4174, 3, 1051, 525, 0, 4174, 718, 1, 0, 0, 0, 4175, 4176, + 3, 1047, 523, 0, 4176, 4177, 3, 1017, 508, 0, 4177, 4178, 3, 1051, 525, + 0, 4178, 4179, 3, 1017, 508, 0, 4179, 4180, 3, 1041, 520, 0, 4180, 4181, + 3, 1025, 512, 0, 4181, 4182, 3, 1055, 527, 0, 4182, 4183, 3, 1025, 512, + 0, 4183, 4184, 3, 1051, 525, 0, 4184, 4185, 3, 1053, 526, 0, 4185, 720, + 1, 0, 0, 0, 4186, 4187, 3, 1031, 515, 0, 4187, 4188, 3, 1025, 512, 0, 4188, + 4189, 3, 1017, 508, 0, 4189, 4190, 3, 1023, 511, 0, 4190, 4191, 3, 1025, + 512, 0, 4191, 4192, 3, 1051, 525, 0, 4192, 4193, 3, 1053, 526, 0, 4193, + 722, 1, 0, 0, 0, 4194, 4195, 3, 1043, 521, 0, 4195, 4196, 3, 1017, 508, + 0, 4196, 4197, 3, 1059, 529, 0, 4197, 4198, 3, 1033, 516, 0, 4198, 4199, + 3, 1029, 514, 0, 4199, 4200, 3, 1017, 508, 0, 4200, 4201, 3, 1055, 527, + 0, 4201, 4202, 3, 1033, 516, 0, 4202, 4203, 3, 1045, 522, 0, 4203, 4204, + 3, 1043, 521, 0, 4204, 724, 1, 0, 0, 0, 4205, 4206, 3, 1041, 520, 0, 4206, + 4207, 3, 1025, 512, 0, 4207, 4208, 3, 1043, 521, 0, 4208, 4209, 3, 1057, + 528, 0, 4209, 726, 1, 0, 0, 0, 4210, 4211, 3, 1031, 515, 0, 4211, 4212, + 3, 1045, 522, 0, 4212, 4213, 3, 1041, 520, 0, 4213, 4214, 3, 1025, 512, + 0, 4214, 4215, 3, 1053, 526, 0, 4215, 728, 1, 0, 0, 0, 4216, 4217, 3, 1031, + 515, 0, 4217, 4218, 3, 1045, 522, 0, 4218, 4219, 3, 1041, 520, 0, 4219, + 4220, 3, 1025, 512, 0, 4220, 730, 1, 0, 0, 0, 4221, 4222, 3, 1039, 519, + 0, 4222, 4223, 3, 1045, 522, 0, 4223, 4224, 3, 1029, 514, 0, 4224, 4225, + 3, 1033, 516, 0, 4225, 4226, 3, 1043, 521, 0, 4226, 732, 1, 0, 0, 0, 4227, + 4228, 3, 1027, 513, 0, 4228, 4229, 3, 1045, 522, 0, 4229, 4230, 3, 1057, + 528, 0, 4230, 4231, 3, 1043, 521, 0, 4231, 4232, 3, 1023, 511, 0, 4232, + 734, 1, 0, 0, 0, 4233, 4234, 3, 1041, 520, 0, 4234, 4235, 3, 1045, 522, + 0, 4235, 4236, 3, 1023, 511, 0, 4236, 4237, 3, 1057, 528, 0, 4237, 4238, + 3, 1039, 519, 0, 4238, 4239, 3, 1025, 512, 0, 4239, 4240, 3, 1053, 526, + 0, 4240, 736, 1, 0, 0, 0, 4241, 4242, 3, 1025, 512, 0, 4242, 4243, 3, 1043, + 521, 0, 4243, 4244, 3, 1055, 527, 0, 4244, 4245, 3, 1033, 516, 0, 4245, + 4246, 3, 1055, 527, 0, 4246, 4247, 3, 1033, 516, 0, 4247, 4248, 3, 1025, + 512, 0, 4248, 4249, 3, 1053, 526, 0, 4249, 738, 1, 0, 0, 0, 4250, 4251, + 3, 1017, 508, 0, 4251, 4252, 3, 1053, 526, 0, 4252, 4253, 3, 1053, 526, + 0, 4253, 4254, 3, 1045, 522, 0, 4254, 4255, 3, 1021, 510, 0, 4255, 4256, + 3, 1033, 516, 0, 4256, 4257, 3, 1017, 508, 0, 4257, 4258, 3, 1055, 527, + 0, 4258, 4259, 3, 1033, 516, 0, 4259, 4260, 3, 1045, 522, 0, 4260, 4261, + 3, 1043, 521, 0, 4261, 4262, 3, 1053, 526, 0, 4262, 740, 1, 0, 0, 0, 4263, + 4264, 3, 1041, 520, 0, 4264, 4265, 3, 1033, 516, 0, 4265, 4266, 3, 1021, + 510, 0, 4266, 4267, 3, 1051, 525, 0, 4267, 4268, 3, 1045, 522, 0, 4268, + 4269, 3, 1027, 513, 0, 4269, 4270, 3, 1039, 519, 0, 4270, 4271, 3, 1045, + 522, 0, 4271, 4272, 3, 1061, 530, 0, 4272, 4273, 3, 1053, 526, 0, 4273, + 742, 1, 0, 0, 0, 4274, 4275, 3, 1043, 521, 0, 4275, 4276, 3, 1017, 508, + 0, 4276, 4277, 3, 1043, 521, 0, 4277, 4278, 3, 1045, 522, 0, 4278, 4279, + 3, 1027, 513, 0, 4279, 4280, 3, 1039, 519, 0, 4280, 4281, 3, 1045, 522, + 0, 4281, 4282, 3, 1061, 530, 0, 4282, 4283, 3, 1053, 526, 0, 4283, 744, + 1, 0, 0, 0, 4284, 4285, 3, 1061, 530, 0, 4285, 4286, 3, 1045, 522, 0, 4286, + 4287, 3, 1051, 525, 0, 4287, 4288, 3, 1037, 518, 0, 4288, 4289, 3, 1027, + 513, 0, 4289, 4290, 3, 1039, 519, 0, 4290, 4291, 3, 1045, 522, 0, 4291, + 4292, 3, 1061, 530, 0, 4292, 4293, 3, 1053, 526, 0, 4293, 746, 1, 0, 0, + 0, 4294, 4295, 3, 1025, 512, 0, 4295, 4296, 3, 1043, 521, 0, 4296, 4297, + 3, 1057, 528, 0, 4297, 4298, 3, 1041, 520, 0, 4298, 4299, 3, 1025, 512, + 0, 4299, 4300, 3, 1051, 525, 0, 4300, 4301, 3, 1017, 508, 0, 4301, 4302, + 3, 1055, 527, 0, 4302, 4303, 3, 1033, 516, 0, 4303, 4304, 3, 1045, 522, + 0, 4304, 4305, 3, 1043, 521, 0, 4305, 4306, 3, 1053, 526, 0, 4306, 748, + 1, 0, 0, 0, 4307, 4308, 3, 1021, 510, 0, 4308, 4309, 3, 1045, 522, 0, 4309, + 4310, 3, 1043, 521, 0, 4310, 4311, 3, 1053, 526, 0, 4311, 4312, 3, 1055, + 527, 0, 4312, 4313, 3, 1017, 508, 0, 4313, 4314, 3, 1043, 521, 0, 4314, + 4315, 3, 1055, 527, 0, 4315, 4316, 3, 1053, 526, 0, 4316, 750, 1, 0, 0, + 0, 4317, 4318, 3, 1021, 510, 0, 4318, 4319, 3, 1045, 522, 0, 4319, 4320, + 3, 1043, 521, 0, 4320, 4321, 3, 1043, 521, 0, 4321, 4322, 3, 1025, 512, + 0, 4322, 4323, 3, 1021, 510, 0, 4323, 4324, 3, 1055, 527, 0, 4324, 4325, + 3, 1033, 516, 0, 4325, 4326, 3, 1045, 522, 0, 4326, 4327, 3, 1043, 521, + 0, 4327, 4328, 3, 1053, 526, 0, 4328, 752, 1, 0, 0, 0, 4329, 4330, 3, 1023, + 511, 0, 4330, 4331, 3, 1025, 512, 0, 4331, 4332, 3, 1027, 513, 0, 4332, + 4333, 3, 1033, 516, 0, 4333, 4334, 3, 1043, 521, 0, 4334, 4335, 3, 1025, + 512, 0, 4335, 754, 1, 0, 0, 0, 4336, 4337, 3, 1027, 513, 0, 4337, 4338, + 3, 1051, 525, 0, 4338, 4339, 3, 1017, 508, 0, 4339, 4340, 3, 1029, 514, + 0, 4340, 4341, 3, 1041, 520, 0, 4341, 4342, 3, 1025, 512, 0, 4342, 4343, + 3, 1043, 521, 0, 4343, 4344, 3, 1055, 527, 0, 4344, 756, 1, 0, 0, 0, 4345, + 4346, 3, 1027, 513, 0, 4346, 4347, 3, 1051, 525, 0, 4347, 4348, 3, 1017, + 508, 0, 4348, 4349, 3, 1029, 514, 0, 4349, 4350, 3, 1041, 520, 0, 4350, + 4351, 3, 1025, 512, 0, 4351, 4352, 3, 1043, 521, 0, 4352, 4353, 3, 1055, + 527, 0, 4353, 4354, 3, 1053, 526, 0, 4354, 758, 1, 0, 0, 0, 4355, 4356, + 3, 1033, 516, 0, 4356, 4357, 3, 1043, 521, 0, 4357, 4358, 3, 1053, 526, + 0, 4358, 4359, 3, 1025, 512, 0, 4359, 4360, 3, 1051, 525, 0, 4360, 4361, + 3, 1055, 527, 0, 4361, 760, 1, 0, 0, 0, 4362, 4363, 3, 1019, 509, 0, 4363, + 4364, 3, 1025, 512, 0, 4364, 4365, 3, 1027, 513, 0, 4365, 4366, 3, 1045, + 522, 0, 4366, 4367, 3, 1051, 525, 0, 4367, 4368, 3, 1025, 512, 0, 4368, + 762, 1, 0, 0, 0, 4369, 4370, 3, 1017, 508, 0, 4370, 4371, 3, 1027, 513, + 0, 4371, 4372, 3, 1055, 527, 0, 4372, 4373, 3, 1025, 512, 0, 4373, 4374, + 3, 1051, 525, 0, 4374, 764, 1, 0, 0, 0, 4375, 4376, 3, 1057, 528, 0, 4376, + 4377, 3, 1047, 523, 0, 4377, 4378, 3, 1023, 511, 0, 4378, 4379, 3, 1017, + 508, 0, 4379, 4380, 3, 1055, 527, 0, 4380, 4381, 3, 1025, 512, 0, 4381, + 766, 1, 0, 0, 0, 4382, 4383, 3, 1051, 525, 0, 4383, 4384, 3, 1025, 512, + 0, 4384, 4385, 3, 1027, 513, 0, 4385, 4386, 3, 1051, 525, 0, 4386, 4387, + 3, 1025, 512, 0, 4387, 4388, 3, 1053, 526, 0, 4388, 4389, 3, 1031, 515, + 0, 4389, 768, 1, 0, 0, 0, 4390, 4391, 3, 1021, 510, 0, 4391, 4392, 3, 1031, + 515, 0, 4392, 4393, 3, 1025, 512, 0, 4393, 4394, 3, 1021, 510, 0, 4394, + 4395, 3, 1037, 518, 0, 4395, 770, 1, 0, 0, 0, 4396, 4397, 3, 1019, 509, + 0, 4397, 4398, 3, 1057, 528, 0, 4398, 4399, 3, 1033, 516, 0, 4399, 4400, + 3, 1039, 519, 0, 4400, 4401, 3, 1023, 511, 0, 4401, 772, 1, 0, 0, 0, 4402, + 4403, 3, 1025, 512, 0, 4403, 4404, 3, 1063, 531, 0, 4404, 4405, 3, 1025, + 512, 0, 4405, 4406, 3, 1021, 510, 0, 4406, 4407, 3, 1057, 528, 0, 4407, + 4408, 3, 1055, 527, 0, 4408, 4409, 3, 1025, 512, 0, 4409, 774, 1, 0, 0, + 0, 4410, 4411, 3, 1053, 526, 0, 4411, 4412, 3, 1021, 510, 0, 4412, 4413, + 3, 1051, 525, 0, 4413, 4414, 3, 1033, 516, 0, 4414, 4415, 3, 1047, 523, + 0, 4415, 4416, 3, 1055, 527, 0, 4416, 776, 1, 0, 0, 0, 4417, 4418, 3, 1039, + 519, 0, 4418, 4419, 3, 1033, 516, 0, 4419, 4420, 3, 1043, 521, 0, 4420, + 4421, 3, 1055, 527, 0, 4421, 778, 1, 0, 0, 0, 4422, 4423, 3, 1051, 525, + 0, 4423, 4424, 3, 1057, 528, 0, 4424, 4425, 3, 1039, 519, 0, 4425, 4426, + 3, 1025, 512, 0, 4426, 4427, 3, 1053, 526, 0, 4427, 780, 1, 0, 0, 0, 4428, + 4429, 3, 1055, 527, 0, 4429, 4430, 3, 1025, 512, 0, 4430, 4431, 3, 1063, + 531, 0, 4431, 4432, 3, 1055, 527, 0, 4432, 782, 1, 0, 0, 0, 4433, 4434, + 3, 1053, 526, 0, 4434, 4435, 3, 1017, 508, 0, 4435, 4436, 3, 1051, 525, + 0, 4436, 4437, 3, 1033, 516, 0, 4437, 4438, 3, 1027, 513, 0, 4438, 784, + 1, 0, 0, 0, 4439, 4440, 3, 1041, 520, 0, 4440, 4441, 3, 1025, 512, 0, 4441, + 4442, 3, 1053, 526, 0, 4442, 4443, 3, 1053, 526, 0, 4443, 4444, 3, 1017, + 508, 0, 4444, 4445, 3, 1029, 514, 0, 4445, 4446, 3, 1025, 512, 0, 4446, + 786, 1, 0, 0, 0, 4447, 4448, 3, 1021, 510, 0, 4448, 4449, 3, 1045, 522, + 0, 4449, 4450, 3, 1041, 520, 0, 4450, 4451, 3, 1041, 520, 0, 4451, 4452, + 3, 1025, 512, 0, 4452, 4453, 3, 1043, 521, 0, 4453, 4454, 3, 1055, 527, + 0, 4454, 788, 1, 0, 0, 0, 4455, 4456, 3, 1021, 510, 0, 4456, 4457, 3, 1017, + 508, 0, 4457, 4458, 3, 1055, 527, 0, 4458, 4459, 3, 1017, 508, 0, 4459, + 4460, 3, 1039, 519, 0, 4460, 4461, 3, 1045, 522, 0, 4461, 4462, 3, 1029, + 514, 0, 4462, 790, 1, 0, 0, 0, 4463, 4464, 3, 1027, 513, 0, 4464, 4465, + 3, 1045, 522, 0, 4465, 4466, 3, 1051, 525, 0, 4466, 4467, 3, 1021, 510, + 0, 4467, 4468, 3, 1025, 512, 0, 4468, 792, 1, 0, 0, 0, 4469, 4470, 3, 1019, + 509, 0, 4470, 4471, 3, 1017, 508, 0, 4471, 4472, 3, 1021, 510, 0, 4472, + 4473, 3, 1037, 518, 0, 4473, 4474, 3, 1029, 514, 0, 4474, 4475, 3, 1051, + 525, 0, 4475, 4476, 3, 1045, 522, 0, 4476, 4477, 3, 1057, 528, 0, 4477, + 4478, 3, 1043, 521, 0, 4478, 4479, 3, 1023, 511, 0, 4479, 794, 1, 0, 0, + 0, 4480, 4481, 3, 1021, 510, 0, 4481, 4482, 3, 1017, 508, 0, 4482, 4483, + 3, 1039, 519, 0, 4483, 4484, 3, 1039, 519, 0, 4484, 4485, 3, 1025, 512, + 0, 4485, 4486, 3, 1051, 525, 0, 4486, 4487, 3, 1053, 526, 0, 4487, 796, + 1, 0, 0, 0, 4488, 4489, 3, 1021, 510, 0, 4489, 4490, 3, 1017, 508, 0, 4490, + 4491, 3, 1039, 519, 0, 4491, 4492, 3, 1039, 519, 0, 4492, 4493, 3, 1025, + 512, 0, 4493, 4494, 3, 1025, 512, 0, 4494, 4495, 3, 1053, 526, 0, 4495, + 798, 1, 0, 0, 0, 4496, 4497, 3, 1051, 525, 0, 4497, 4498, 3, 1025, 512, + 0, 4498, 4499, 3, 1027, 513, 0, 4499, 4500, 3, 1025, 512, 0, 4500, 4501, + 3, 1051, 525, 0, 4501, 4502, 3, 1025, 512, 0, 4502, 4503, 3, 1043, 521, + 0, 4503, 4504, 3, 1021, 510, 0, 4504, 4505, 3, 1025, 512, 0, 4505, 4506, + 3, 1053, 526, 0, 4506, 800, 1, 0, 0, 0, 4507, 4508, 3, 1055, 527, 0, 4508, + 4509, 3, 1051, 525, 0, 4509, 4510, 3, 1017, 508, 0, 4510, 4511, 3, 1043, + 521, 0, 4511, 4512, 3, 1053, 526, 0, 4512, 4513, 3, 1033, 516, 0, 4513, + 4514, 3, 1055, 527, 0, 4514, 4515, 3, 1033, 516, 0, 4515, 4516, 3, 1059, + 529, 0, 4516, 4517, 3, 1025, 512, 0, 4517, 802, 1, 0, 0, 0, 4518, 4519, + 3, 1033, 516, 0, 4519, 4520, 3, 1041, 520, 0, 4520, 4521, 3, 1047, 523, + 0, 4521, 4522, 3, 1017, 508, 0, 4522, 4523, 3, 1021, 510, 0, 4523, 4524, + 3, 1055, 527, 0, 4524, 804, 1, 0, 0, 0, 4525, 4526, 3, 1023, 511, 0, 4526, + 4527, 3, 1025, 512, 0, 4527, 4528, 3, 1047, 523, 0, 4528, 4529, 3, 1055, + 527, 0, 4529, 4530, 3, 1031, 515, 0, 4530, 806, 1, 0, 0, 0, 4531, 4532, + 3, 1053, 526, 0, 4532, 4533, 3, 1055, 527, 0, 4533, 4534, 3, 1051, 525, + 0, 4534, 4535, 3, 1057, 528, 0, 4535, 4536, 3, 1021, 510, 0, 4536, 4537, + 3, 1055, 527, 0, 4537, 4538, 3, 1057, 528, 0, 4538, 4539, 3, 1051, 525, + 0, 4539, 4540, 3, 1025, 512, 0, 4540, 808, 1, 0, 0, 0, 4541, 4542, 3, 1055, + 527, 0, 4542, 4543, 3, 1065, 532, 0, 4543, 4544, 3, 1047, 523, 0, 4544, + 4545, 3, 1025, 512, 0, 4545, 810, 1, 0, 0, 0, 4546, 4547, 3, 1059, 529, + 0, 4547, 4548, 3, 1017, 508, 0, 4548, 4549, 3, 1039, 519, 0, 4549, 4550, + 3, 1057, 528, 0, 4550, 4551, 3, 1025, 512, 0, 4551, 812, 1, 0, 0, 0, 4552, + 4553, 3, 1053, 526, 0, 4553, 4554, 3, 1033, 516, 0, 4554, 4555, 3, 1043, + 521, 0, 4555, 4556, 3, 1029, 514, 0, 4556, 4557, 3, 1039, 519, 0, 4557, + 4558, 3, 1025, 512, 0, 4558, 814, 1, 0, 0, 0, 4559, 4560, 3, 1041, 520, + 0, 4560, 4561, 3, 1057, 528, 0, 4561, 4562, 3, 1039, 519, 0, 4562, 4563, + 3, 1055, 527, 0, 4563, 4564, 3, 1033, 516, 0, 4564, 4565, 3, 1047, 523, + 0, 4565, 4566, 3, 1039, 519, 0, 4566, 4567, 3, 1025, 512, 0, 4567, 816, + 1, 0, 0, 0, 4568, 4569, 3, 1043, 521, 0, 4569, 4570, 3, 1045, 522, 0, 4570, + 4571, 3, 1043, 521, 0, 4571, 4572, 3, 1025, 512, 0, 4572, 818, 1, 0, 0, + 0, 4573, 4574, 3, 1019, 509, 0, 4574, 4575, 3, 1045, 522, 0, 4575, 4576, + 3, 1055, 527, 0, 4576, 4577, 3, 1031, 515, 0, 4577, 820, 1, 0, 0, 0, 4578, + 4579, 3, 1055, 527, 0, 4579, 4580, 3, 1045, 522, 0, 4580, 822, 1, 0, 0, + 0, 4581, 4582, 3, 1045, 522, 0, 4582, 4583, 3, 1027, 513, 0, 4583, 824, + 1, 0, 0, 0, 4584, 4585, 3, 1045, 522, 0, 4585, 4586, 3, 1059, 529, 0, 4586, + 4587, 3, 1025, 512, 0, 4587, 4588, 3, 1051, 525, 0, 4588, 826, 1, 0, 0, + 0, 4589, 4590, 3, 1027, 513, 0, 4590, 4591, 3, 1045, 522, 0, 4591, 4592, + 3, 1051, 525, 0, 4592, 828, 1, 0, 0, 0, 4593, 4594, 3, 1051, 525, 0, 4594, + 4595, 3, 1025, 512, 0, 4595, 4596, 3, 1047, 523, 0, 4596, 4597, 3, 1039, + 519, 0, 4597, 4598, 3, 1017, 508, 0, 4598, 4599, 3, 1021, 510, 0, 4599, + 4600, 3, 1025, 512, 0, 4600, 830, 1, 0, 0, 0, 4601, 4602, 3, 1041, 520, + 0, 4602, 4603, 3, 1025, 512, 0, 4603, 4604, 3, 1041, 520, 0, 4604, 4605, + 3, 1019, 509, 0, 4605, 4606, 3, 1025, 512, 0, 4606, 4607, 3, 1051, 525, + 0, 4607, 4608, 3, 1053, 526, 0, 4608, 832, 1, 0, 0, 0, 4609, 4610, 3, 1017, + 508, 0, 4610, 4611, 3, 1055, 527, 0, 4611, 4612, 3, 1055, 527, 0, 4612, + 4613, 3, 1051, 525, 0, 4613, 4614, 3, 1033, 516, 0, 4614, 4615, 3, 1019, + 509, 0, 4615, 4616, 3, 1057, 528, 0, 4616, 4617, 3, 1055, 527, 0, 4617, + 4618, 3, 1025, 512, 0, 4618, 4619, 3, 1043, 521, 0, 4619, 4620, 3, 1017, + 508, 0, 4620, 4621, 3, 1041, 520, 0, 4621, 4622, 3, 1025, 512, 0, 4622, + 834, 1, 0, 0, 0, 4623, 4624, 3, 1027, 513, 0, 4624, 4625, 3, 1045, 522, + 0, 4625, 4626, 3, 1051, 525, 0, 4626, 4627, 3, 1041, 520, 0, 4627, 4628, + 3, 1017, 508, 0, 4628, 4629, 3, 1055, 527, 0, 4629, 836, 1, 0, 0, 0, 4630, + 4631, 3, 1053, 526, 0, 4631, 4632, 3, 1049, 524, 0, 4632, 4633, 3, 1039, + 519, 0, 4633, 838, 1, 0, 0, 0, 4634, 4635, 3, 1061, 530, 0, 4635, 4636, + 3, 1033, 516, 0, 4636, 4637, 3, 1055, 527, 0, 4637, 4638, 3, 1031, 515, + 0, 4638, 4639, 3, 1045, 522, 0, 4639, 4640, 3, 1057, 528, 0, 4640, 4641, + 3, 1055, 527, 0, 4641, 840, 1, 0, 0, 0, 4642, 4643, 3, 1023, 511, 0, 4643, + 4644, 3, 1051, 525, 0, 4644, 4645, 3, 1065, 532, 0, 4645, 842, 1, 0, 0, + 0, 4646, 4647, 3, 1051, 525, 0, 4647, 4648, 3, 1057, 528, 0, 4648, 4649, + 3, 1043, 521, 0, 4649, 844, 1, 0, 0, 0, 4650, 4651, 3, 1061, 530, 0, 4651, + 4652, 3, 1033, 516, 0, 4652, 4653, 3, 1023, 511, 0, 4653, 4654, 3, 1029, + 514, 0, 4654, 4655, 3, 1025, 512, 0, 4655, 4656, 3, 1055, 527, 0, 4656, + 4657, 3, 1055, 527, 0, 4657, 4658, 3, 1065, 532, 0, 4658, 4659, 3, 1047, + 523, 0, 4659, 4660, 3, 1025, 512, 0, 4660, 846, 1, 0, 0, 0, 4661, 4662, + 3, 1059, 529, 0, 4662, 4663, 5, 51, 0, 0, 4663, 848, 1, 0, 0, 0, 4664, + 4665, 3, 1019, 509, 0, 4665, 4666, 3, 1057, 528, 0, 4666, 4667, 3, 1053, + 526, 0, 4667, 4668, 3, 1033, 516, 0, 4668, 4669, 3, 1043, 521, 0, 4669, + 4670, 3, 1025, 512, 0, 4670, 4671, 3, 1053, 526, 0, 4671, 4672, 3, 1053, + 526, 0, 4672, 850, 1, 0, 0, 0, 4673, 4674, 3, 1025, 512, 0, 4674, 4675, + 3, 1059, 529, 0, 4675, 4676, 3, 1025, 512, 0, 4676, 4677, 3, 1043, 521, + 0, 4677, 4678, 3, 1055, 527, 0, 4678, 852, 1, 0, 0, 0, 4679, 4680, 3, 1053, + 526, 0, 4680, 4681, 3, 1057, 528, 0, 4681, 4682, 3, 1019, 509, 0, 4682, + 4683, 3, 1053, 526, 0, 4683, 4684, 3, 1021, 510, 0, 4684, 4685, 3, 1051, + 525, 0, 4685, 4686, 3, 1033, 516, 0, 4686, 4687, 3, 1019, 509, 0, 4687, + 4688, 3, 1025, 512, 0, 4688, 854, 1, 0, 0, 0, 4689, 4690, 3, 1053, 526, + 0, 4690, 4691, 3, 1025, 512, 0, 4691, 4692, 3, 1055, 527, 0, 4692, 4693, + 3, 1055, 527, 0, 4693, 4694, 3, 1033, 516, 0, 4694, 4695, 3, 1043, 521, + 0, 4695, 4696, 3, 1029, 514, 0, 4696, 4697, 3, 1053, 526, 0, 4697, 856, + 1, 0, 0, 0, 4698, 4699, 3, 1021, 510, 0, 4699, 4700, 3, 1045, 522, 0, 4700, + 4701, 3, 1043, 521, 0, 4701, 4702, 3, 1027, 513, 0, 4702, 4703, 3, 1033, + 516, 0, 4703, 4704, 3, 1029, 514, 0, 4704, 4705, 3, 1057, 528, 0, 4705, + 4706, 3, 1051, 525, 0, 4706, 4707, 3, 1017, 508, 0, 4707, 4708, 3, 1055, + 527, 0, 4708, 4709, 3, 1033, 516, 0, 4709, 4710, 3, 1045, 522, 0, 4710, + 4711, 3, 1043, 521, 0, 4711, 858, 1, 0, 0, 0, 4712, 4713, 3, 1053, 526, + 0, 4713, 4714, 3, 1025, 512, 0, 4714, 4715, 3, 1021, 510, 0, 4715, 4716, + 3, 1057, 528, 0, 4716, 4717, 3, 1051, 525, 0, 4717, 4718, 3, 1033, 516, + 0, 4718, 4719, 3, 1055, 527, 0, 4719, 4720, 3, 1065, 532, 0, 4720, 860, + 1, 0, 0, 0, 4721, 4722, 3, 1051, 525, 0, 4722, 4723, 3, 1045, 522, 0, 4723, + 4724, 3, 1039, 519, 0, 4724, 4725, 3, 1025, 512, 0, 4725, 862, 1, 0, 0, + 0, 4726, 4727, 3, 1051, 525, 0, 4727, 4728, 3, 1045, 522, 0, 4728, 4729, + 3, 1039, 519, 0, 4729, 4730, 3, 1025, 512, 0, 4730, 4731, 3, 1053, 526, + 0, 4731, 864, 1, 0, 0, 0, 4732, 4733, 3, 1029, 514, 0, 4733, 4734, 3, 1051, + 525, 0, 4734, 4735, 3, 1017, 508, 0, 4735, 4736, 3, 1043, 521, 0, 4736, + 4737, 3, 1055, 527, 0, 4737, 866, 1, 0, 0, 0, 4738, 4739, 3, 1051, 525, + 0, 4739, 4740, 3, 1025, 512, 0, 4740, 4741, 3, 1059, 529, 0, 4741, 4742, + 3, 1045, 522, 0, 4742, 4743, 3, 1037, 518, 0, 4743, 4744, 3, 1025, 512, + 0, 4744, 868, 1, 0, 0, 0, 4745, 4746, 3, 1047, 523, 0, 4746, 4747, 3, 1051, + 525, 0, 4747, 4748, 3, 1045, 522, 0, 4748, 4749, 3, 1023, 511, 0, 4749, + 4750, 3, 1057, 528, 0, 4750, 4751, 3, 1021, 510, 0, 4751, 4752, 3, 1055, + 527, 0, 4752, 4753, 3, 1033, 516, 0, 4753, 4754, 3, 1045, 522, 0, 4754, + 4755, 3, 1043, 521, 0, 4755, 870, 1, 0, 0, 0, 4756, 4757, 3, 1047, 523, + 0, 4757, 4758, 3, 1051, 525, 0, 4758, 4759, 3, 1045, 522, 0, 4759, 4760, + 3, 1055, 527, 0, 4760, 4761, 3, 1045, 522, 0, 4761, 4762, 3, 1055, 527, + 0, 4762, 4763, 3, 1065, 532, 0, 4763, 4764, 3, 1047, 523, 0, 4764, 4765, + 3, 1025, 512, 0, 4765, 872, 1, 0, 0, 0, 4766, 4767, 3, 1041, 520, 0, 4767, + 4768, 3, 1017, 508, 0, 4768, 4769, 3, 1043, 521, 0, 4769, 4770, 3, 1017, + 508, 0, 4770, 4771, 3, 1029, 514, 0, 4771, 4772, 3, 1025, 512, 0, 4772, + 874, 1, 0, 0, 0, 4773, 4774, 3, 1023, 511, 0, 4774, 4775, 3, 1025, 512, + 0, 4775, 4776, 3, 1041, 520, 0, 4776, 4777, 3, 1045, 522, 0, 4777, 876, + 1, 0, 0, 0, 4778, 4779, 3, 1041, 520, 0, 4779, 4780, 3, 1017, 508, 0, 4780, + 4781, 3, 1055, 527, 0, 4781, 4782, 3, 1051, 525, 0, 4782, 4783, 3, 1033, + 516, 0, 4783, 4784, 3, 1063, 531, 0, 4784, 878, 1, 0, 0, 0, 4785, 4786, + 3, 1017, 508, 0, 4786, 4787, 3, 1047, 523, 0, 4787, 4788, 3, 1047, 523, + 0, 4788, 4789, 3, 1039, 519, 0, 4789, 4790, 3, 1065, 532, 0, 4790, 880, + 1, 0, 0, 0, 4791, 4792, 3, 1017, 508, 0, 4792, 4793, 3, 1021, 510, 0, 4793, + 4794, 3, 1021, 510, 0, 4794, 4795, 3, 1025, 512, 0, 4795, 4796, 3, 1053, + 526, 0, 4796, 4797, 3, 1053, 526, 0, 4797, 882, 1, 0, 0, 0, 4798, 4799, + 3, 1039, 519, 0, 4799, 4800, 3, 1025, 512, 0, 4800, 4801, 3, 1059, 529, + 0, 4801, 4802, 3, 1025, 512, 0, 4802, 4803, 3, 1039, 519, 0, 4803, 884, + 1, 0, 0, 0, 4804, 4805, 3, 1057, 528, 0, 4805, 4806, 3, 1053, 526, 0, 4806, + 4807, 3, 1025, 512, 0, 4807, 4808, 3, 1051, 525, 0, 4808, 886, 1, 0, 0, + 0, 4809, 4810, 3, 1055, 527, 0, 4810, 4811, 3, 1017, 508, 0, 4811, 4812, + 3, 1053, 526, 0, 4812, 4813, 3, 1037, 518, 0, 4813, 888, 1, 0, 0, 0, 4814, + 4815, 3, 1023, 511, 0, 4815, 4816, 3, 1025, 512, 0, 4816, 4817, 3, 1021, + 510, 0, 4817, 4818, 3, 1033, 516, 0, 4818, 4819, 3, 1053, 526, 0, 4819, + 4820, 3, 1033, 516, 0, 4820, 4821, 3, 1045, 522, 0, 4821, 4822, 3, 1043, + 521, 0, 4822, 890, 1, 0, 0, 0, 4823, 4824, 3, 1053, 526, 0, 4824, 4825, + 3, 1047, 523, 0, 4825, 4826, 3, 1039, 519, 0, 4826, 4827, 3, 1033, 516, + 0, 4827, 4828, 3, 1055, 527, 0, 4828, 892, 1, 0, 0, 0, 4829, 4830, 3, 1045, + 522, 0, 4830, 4831, 3, 1057, 528, 0, 4831, 4832, 3, 1055, 527, 0, 4832, + 4833, 3, 1021, 510, 0, 4833, 4834, 3, 1045, 522, 0, 4834, 4835, 3, 1041, + 520, 0, 4835, 4836, 3, 1025, 512, 0, 4836, 4837, 3, 1053, 526, 0, 4837, + 894, 1, 0, 0, 0, 4838, 4839, 3, 1055, 527, 0, 4839, 4840, 3, 1017, 508, + 0, 4840, 4841, 3, 1051, 525, 0, 4841, 4842, 3, 1029, 514, 0, 4842, 4843, + 3, 1025, 512, 0, 4843, 4844, 3, 1055, 527, 0, 4844, 4845, 3, 1033, 516, + 0, 4845, 4846, 3, 1043, 521, 0, 4846, 4847, 3, 1029, 514, 0, 4847, 896, + 1, 0, 0, 0, 4848, 4849, 3, 1043, 521, 0, 4849, 4850, 3, 1045, 522, 0, 4850, + 4851, 3, 1055, 527, 0, 4851, 4852, 3, 1033, 516, 0, 4852, 4853, 3, 1027, + 513, 0, 4853, 4854, 3, 1033, 516, 0, 4854, 4855, 3, 1021, 510, 0, 4855, + 4856, 3, 1017, 508, 0, 4856, 4857, 3, 1055, 527, 0, 4857, 4858, 3, 1033, + 516, 0, 4858, 4859, 3, 1045, 522, 0, 4859, 4860, 3, 1043, 521, 0, 4860, + 898, 1, 0, 0, 0, 4861, 4862, 3, 1055, 527, 0, 4862, 4863, 3, 1033, 516, + 0, 4863, 4864, 3, 1041, 520, 0, 4864, 4865, 3, 1025, 512, 0, 4865, 4866, + 3, 1051, 525, 0, 4866, 900, 1, 0, 0, 0, 4867, 4868, 3, 1035, 517, 0, 4868, + 4869, 3, 1057, 528, 0, 4869, 4870, 3, 1041, 520, 0, 4870, 4871, 3, 1047, + 523, 0, 4871, 902, 1, 0, 0, 0, 4872, 4873, 3, 1023, 511, 0, 4873, 4874, + 3, 1057, 528, 0, 4874, 4875, 3, 1025, 512, 0, 4875, 904, 1, 0, 0, 0, 4876, + 4877, 3, 1045, 522, 0, 4877, 4878, 3, 1059, 529, 0, 4878, 4879, 3, 1025, + 512, 0, 4879, 4880, 3, 1051, 525, 0, 4880, 4881, 3, 1059, 529, 0, 4881, + 4882, 3, 1033, 516, 0, 4882, 4883, 3, 1025, 512, 0, 4883, 4884, 3, 1061, + 530, 0, 4884, 906, 1, 0, 0, 0, 4885, 4886, 3, 1023, 511, 0, 4886, 4887, + 3, 1017, 508, 0, 4887, 4888, 3, 1055, 527, 0, 4888, 4889, 3, 1025, 512, + 0, 4889, 908, 1, 0, 0, 0, 4890, 4891, 3, 1047, 523, 0, 4891, 4892, 3, 1017, + 508, 0, 4892, 4893, 3, 1051, 525, 0, 4893, 4894, 3, 1017, 508, 0, 4894, + 4895, 3, 1039, 519, 0, 4895, 4896, 3, 1039, 519, 0, 4896, 4897, 3, 1025, + 512, 0, 4897, 4898, 3, 1039, 519, 0, 4898, 910, 1, 0, 0, 0, 4899, 4900, + 3, 1061, 530, 0, 4900, 4901, 3, 1017, 508, 0, 4901, 4902, 3, 1033, 516, + 0, 4902, 4903, 3, 1055, 527, 0, 4903, 912, 1, 0, 0, 0, 4904, 4905, 3, 1017, + 508, 0, 4905, 4906, 3, 1043, 521, 0, 4906, 4907, 3, 1043, 521, 0, 4907, + 4908, 3, 1045, 522, 0, 4908, 4909, 3, 1055, 527, 0, 4909, 4910, 3, 1017, + 508, 0, 4910, 4911, 3, 1055, 527, 0, 4911, 4912, 3, 1033, 516, 0, 4912, + 4913, 3, 1045, 522, 0, 4913, 4914, 3, 1043, 521, 0, 4914, 914, 1, 0, 0, + 0, 4915, 4916, 3, 1019, 509, 0, 4916, 4917, 3, 1045, 522, 0, 4917, 4918, + 3, 1057, 528, 0, 4918, 4919, 3, 1043, 521, 0, 4919, 4920, 3, 1023, 511, + 0, 4920, 4921, 3, 1017, 508, 0, 4921, 4922, 3, 1051, 525, 0, 4922, 4923, + 3, 1065, 532, 0, 4923, 916, 1, 0, 0, 0, 4924, 4925, 3, 1033, 516, 0, 4925, + 4926, 3, 1043, 521, 0, 4926, 4927, 3, 1055, 527, 0, 4927, 4928, 3, 1025, + 512, 0, 4928, 4929, 3, 1051, 525, 0, 4929, 4930, 3, 1051, 525, 0, 4930, + 4931, 3, 1057, 528, 0, 4931, 4932, 3, 1047, 523, 0, 4932, 4933, 3, 1055, + 527, 0, 4933, 4934, 3, 1033, 516, 0, 4934, 4935, 3, 1043, 521, 0, 4935, + 4936, 3, 1029, 514, 0, 4936, 918, 1, 0, 0, 0, 4937, 4938, 3, 1043, 521, + 0, 4938, 4939, 3, 1045, 522, 0, 4939, 4940, 3, 1043, 521, 0, 4940, 920, + 1, 0, 0, 0, 4941, 4942, 3, 1041, 520, 0, 4942, 4943, 3, 1057, 528, 0, 4943, + 4944, 3, 1039, 519, 0, 4944, 4945, 3, 1055, 527, 0, 4945, 4946, 3, 1033, + 516, 0, 4946, 922, 1, 0, 0, 0, 4947, 4948, 3, 1019, 509, 0, 4948, 4949, + 3, 1065, 532, 0, 4949, 924, 1, 0, 0, 0, 4950, 4951, 3, 1051, 525, 0, 4951, + 4952, 3, 1025, 512, 0, 4952, 4953, 3, 1017, 508, 0, 4953, 4954, 3, 1023, + 511, 0, 4954, 926, 1, 0, 0, 0, 4955, 4956, 3, 1061, 530, 0, 4956, 4957, + 3, 1051, 525, 0, 4957, 4958, 3, 1033, 516, 0, 4958, 4959, 3, 1055, 527, + 0, 4959, 4960, 3, 1025, 512, 0, 4960, 928, 1, 0, 0, 0, 4961, 4962, 3, 1023, + 511, 0, 4962, 4963, 3, 1025, 512, 0, 4963, 4964, 3, 1053, 526, 0, 4964, + 4965, 3, 1021, 510, 0, 4965, 4966, 3, 1051, 525, 0, 4966, 4967, 3, 1033, + 516, 0, 4967, 4968, 3, 1047, 523, 0, 4968, 4969, 3, 1055, 527, 0, 4969, + 4970, 3, 1033, 516, 0, 4970, 4971, 3, 1045, 522, 0, 4971, 4972, 3, 1043, + 521, 0, 4972, 930, 1, 0, 0, 0, 4973, 4974, 3, 1023, 511, 0, 4974, 4975, + 3, 1033, 516, 0, 4975, 4976, 3, 1053, 526, 0, 4976, 4977, 3, 1047, 523, + 0, 4977, 4978, 3, 1039, 519, 0, 4978, 4979, 3, 1017, 508, 0, 4979, 4980, + 3, 1065, 532, 0, 4980, 932, 1, 0, 0, 0, 4981, 4982, 3, 1045, 522, 0, 4982, + 4983, 3, 1027, 513, 0, 4983, 4984, 3, 1027, 513, 0, 4984, 934, 1, 0, 0, + 0, 4985, 4986, 3, 1057, 528, 0, 4986, 4987, 3, 1053, 526, 0, 4987, 4988, + 3, 1025, 512, 0, 4988, 4989, 3, 1051, 525, 0, 4989, 4990, 3, 1053, 526, + 0, 4990, 936, 1, 0, 0, 0, 4991, 4992, 5, 60, 0, 0, 4992, 4996, 5, 62, 0, + 0, 4993, 4994, 5, 33, 0, 0, 4994, 4996, 5, 61, 0, 0, 4995, 4991, 1, 0, + 0, 0, 4995, 4993, 1, 0, 0, 0, 4996, 938, 1, 0, 0, 0, 4997, 4998, 5, 60, + 0, 0, 4998, 4999, 5, 61, 0, 0, 4999, 940, 1, 0, 0, 0, 5000, 5001, 5, 62, + 0, 0, 5001, 5002, 5, 61, 0, 0, 5002, 942, 1, 0, 0, 0, 5003, 5004, 5, 61, + 0, 0, 5004, 944, 1, 0, 0, 0, 5005, 5006, 5, 60, 0, 0, 5006, 946, 1, 0, + 0, 0, 5007, 5008, 5, 62, 0, 0, 5008, 948, 1, 0, 0, 0, 5009, 5010, 5, 43, + 0, 0, 5010, 950, 1, 0, 0, 0, 5011, 5012, 5, 45, 0, 0, 5012, 952, 1, 0, + 0, 0, 5013, 5014, 5, 42, 0, 0, 5014, 954, 1, 0, 0, 0, 5015, 5016, 5, 47, + 0, 0, 5016, 956, 1, 0, 0, 0, 5017, 5018, 5, 37, 0, 0, 5018, 958, 1, 0, + 0, 0, 5019, 5020, 3, 1041, 520, 0, 5020, 5021, 3, 1045, 522, 0, 5021, 5022, + 3, 1023, 511, 0, 5022, 960, 1, 0, 0, 0, 5023, 5024, 3, 1023, 511, 0, 5024, + 5025, 3, 1033, 516, 0, 5025, 5026, 3, 1059, 529, 0, 5026, 962, 1, 0, 0, + 0, 5027, 5028, 5, 59, 0, 0, 5028, 964, 1, 0, 0, 0, 5029, 5030, 5, 44, 0, + 0, 5030, 966, 1, 0, 0, 0, 5031, 5032, 5, 46, 0, 0, 5032, 968, 1, 0, 0, + 0, 5033, 5034, 5, 40, 0, 0, 5034, 970, 1, 0, 0, 0, 5035, 5036, 5, 41, 0, + 0, 5036, 972, 1, 0, 0, 0, 5037, 5038, 5, 123, 0, 0, 5038, 974, 1, 0, 0, + 0, 5039, 5040, 5, 125, 0, 0, 5040, 976, 1, 0, 0, 0, 5041, 5042, 5, 91, + 0, 0, 5042, 978, 1, 0, 0, 0, 5043, 5044, 5, 93, 0, 0, 5044, 980, 1, 0, + 0, 0, 5045, 5046, 5, 58, 0, 0, 5046, 982, 1, 0, 0, 0, 5047, 5048, 5, 64, + 0, 0, 5048, 984, 1, 0, 0, 0, 5049, 5050, 5, 124, 0, 0, 5050, 986, 1, 0, + 0, 0, 5051, 5052, 5, 58, 0, 0, 5052, 5053, 5, 58, 0, 0, 5053, 988, 1, 0, + 0, 0, 5054, 5055, 5, 45, 0, 0, 5055, 5056, 5, 62, 0, 0, 5056, 990, 1, 0, + 0, 0, 5057, 5058, 5, 63, 0, 0, 5058, 992, 1, 0, 0, 0, 5059, 5060, 5, 35, + 0, 0, 5060, 994, 1, 0, 0, 0, 5061, 5062, 5, 91, 0, 0, 5062, 5063, 5, 37, + 0, 0, 5063, 5067, 1, 0, 0, 0, 5064, 5066, 9, 0, 0, 0, 5065, 5064, 1, 0, + 0, 0, 5066, 5069, 1, 0, 0, 0, 5067, 5068, 1, 0, 0, 0, 5067, 5065, 1, 0, + 0, 0, 5068, 5070, 1, 0, 0, 0, 5069, 5067, 1, 0, 0, 0, 5070, 5071, 5, 37, + 0, 0, 5071, 5072, 5, 93, 0, 0, 5072, 996, 1, 0, 0, 0, 5073, 5081, 5, 39, + 0, 0, 5074, 5080, 8, 2, 0, 0, 5075, 5076, 5, 92, 0, 0, 5076, 5080, 9, 0, + 0, 0, 5077, 5078, 5, 39, 0, 0, 5078, 5080, 5, 39, 0, 0, 5079, 5074, 1, + 0, 0, 0, 5079, 5075, 1, 0, 0, 0, 5079, 5077, 1, 0, 0, 0, 5080, 5083, 1, + 0, 0, 0, 5081, 5079, 1, 0, 0, 0, 5081, 5082, 1, 0, 0, 0, 5082, 5084, 1, + 0, 0, 0, 5083, 5081, 1, 0, 0, 0, 5084, 5085, 5, 39, 0, 0, 5085, 998, 1, + 0, 0, 0, 5086, 5087, 5, 36, 0, 0, 5087, 5088, 5, 36, 0, 0, 5088, 5092, + 1, 0, 0, 0, 5089, 5091, 9, 0, 0, 0, 5090, 5089, 1, 0, 0, 0, 5091, 5094, + 1, 0, 0, 0, 5092, 5093, 1, 0, 0, 0, 5092, 5090, 1, 0, 0, 0, 5093, 5095, + 1, 0, 0, 0, 5094, 5092, 1, 0, 0, 0, 5095, 5096, 5, 36, 0, 0, 5096, 5097, + 5, 36, 0, 0, 5097, 1000, 1, 0, 0, 0, 5098, 5100, 5, 45, 0, 0, 5099, 5098, + 1, 0, 0, 0, 5099, 5100, 1, 0, 0, 0, 5100, 5102, 1, 0, 0, 0, 5101, 5103, + 3, 1015, 507, 0, 5102, 5101, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, + 5102, 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 5112, 1, 0, 0, 0, 5106, + 5108, 5, 46, 0, 0, 5107, 5109, 3, 1015, 507, 0, 5108, 5107, 1, 0, 0, 0, + 5109, 5110, 1, 0, 0, 0, 5110, 5108, 1, 0, 0, 0, 5110, 5111, 1, 0, 0, 0, + 5111, 5113, 1, 0, 0, 0, 5112, 5106, 1, 0, 0, 0, 5112, 5113, 1, 0, 0, 0, + 5113, 5123, 1, 0, 0, 0, 5114, 5116, 7, 3, 0, 0, 5115, 5117, 7, 4, 0, 0, + 5116, 5115, 1, 0, 0, 0, 5116, 5117, 1, 0, 0, 0, 5117, 5119, 1, 0, 0, 0, + 5118, 5120, 3, 1015, 507, 0, 5119, 5118, 1, 0, 0, 0, 5120, 5121, 1, 0, + 0, 0, 5121, 5119, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 5124, 1, 0, + 0, 0, 5123, 5114, 1, 0, 0, 0, 5123, 5124, 1, 0, 0, 0, 5124, 1002, 1, 0, + 0, 0, 5125, 5127, 5, 36, 0, 0, 5126, 5128, 3, 1013, 506, 0, 5127, 5126, + 1, 0, 0, 0, 5128, 5129, 1, 0, 0, 0, 5129, 5127, 1, 0, 0, 0, 5129, 5130, + 1, 0, 0, 0, 5130, 1004, 1, 0, 0, 0, 5131, 5135, 3, 1011, 505, 0, 5132, + 5134, 3, 1013, 506, 0, 5133, 5132, 1, 0, 0, 0, 5134, 5137, 1, 0, 0, 0, + 5135, 5133, 1, 0, 0, 0, 5135, 5136, 1, 0, 0, 0, 5136, 1006, 1, 0, 0, 0, + 5137, 5135, 1, 0, 0, 0, 5138, 5146, 3, 1011, 505, 0, 5139, 5141, 3, 1013, + 506, 0, 5140, 5139, 1, 0, 0, 0, 5141, 5144, 1, 0, 0, 0, 5142, 5140, 1, + 0, 0, 0, 5142, 5143, 1, 0, 0, 0, 5143, 5145, 1, 0, 0, 0, 5144, 5142, 1, + 0, 0, 0, 5145, 5147, 5, 45, 0, 0, 5146, 5142, 1, 0, 0, 0, 5147, 5148, 1, + 0, 0, 0, 5148, 5146, 1, 0, 0, 0, 5148, 5149, 1, 0, 0, 0, 5149, 5153, 1, + 0, 0, 0, 5150, 5152, 3, 1013, 506, 0, 5151, 5150, 1, 0, 0, 0, 5152, 5155, + 1, 0, 0, 0, 5153, 5151, 1, 0, 0, 0, 5153, 5154, 1, 0, 0, 0, 5154, 1008, + 1, 0, 0, 0, 5155, 5153, 1, 0, 0, 0, 5156, 5160, 5, 34, 0, 0, 5157, 5159, + 8, 5, 0, 0, 5158, 5157, 1, 0, 0, 0, 5159, 5162, 1, 0, 0, 0, 5160, 5158, + 1, 0, 0, 0, 5160, 5161, 1, 0, 0, 0, 5161, 5163, 1, 0, 0, 0, 5162, 5160, + 1, 0, 0, 0, 5163, 5173, 5, 34, 0, 0, 5164, 5168, 5, 96, 0, 0, 5165, 5167, + 8, 6, 0, 0, 5166, 5165, 1, 0, 0, 0, 5167, 5170, 1, 0, 0, 0, 5168, 5166, + 1, 0, 0, 0, 5168, 5169, 1, 0, 0, 0, 5169, 5171, 1, 0, 0, 0, 5170, 5168, + 1, 0, 0, 0, 5171, 5173, 5, 96, 0, 0, 5172, 5156, 1, 0, 0, 0, 5172, 5164, + 1, 0, 0, 0, 5173, 1010, 1, 0, 0, 0, 5174, 5175, 7, 7, 0, 0, 5175, 1012, + 1, 0, 0, 0, 5176, 5177, 7, 8, 0, 0, 5177, 1014, 1, 0, 0, 0, 5178, 5179, + 7, 9, 0, 0, 5179, 1016, 1, 0, 0, 0, 5180, 5181, 7, 10, 0, 0, 5181, 1018, + 1, 0, 0, 0, 5182, 5183, 7, 11, 0, 0, 5183, 1020, 1, 0, 0, 0, 5184, 5185, + 7, 12, 0, 0, 5185, 1022, 1, 0, 0, 0, 5186, 5187, 7, 13, 0, 0, 5187, 1024, + 1, 0, 0, 0, 5188, 5189, 7, 3, 0, 0, 5189, 1026, 1, 0, 0, 0, 5190, 5191, + 7, 14, 0, 0, 5191, 1028, 1, 0, 0, 0, 5192, 5193, 7, 15, 0, 0, 5193, 1030, + 1, 0, 0, 0, 5194, 5195, 7, 16, 0, 0, 5195, 1032, 1, 0, 0, 0, 5196, 5197, + 7, 17, 0, 0, 5197, 1034, 1, 0, 0, 0, 5198, 5199, 7, 18, 0, 0, 5199, 1036, + 1, 0, 0, 0, 5200, 5201, 7, 19, 0, 0, 5201, 1038, 1, 0, 0, 0, 5202, 5203, + 7, 20, 0, 0, 5203, 1040, 1, 0, 0, 0, 5204, 5205, 7, 21, 0, 0, 5205, 1042, + 1, 0, 0, 0, 5206, 5207, 7, 22, 0, 0, 5207, 1044, 1, 0, 0, 0, 5208, 5209, + 7, 23, 0, 0, 5209, 1046, 1, 0, 0, 0, 5210, 5211, 7, 24, 0, 0, 5211, 1048, + 1, 0, 0, 0, 5212, 5213, 7, 25, 0, 0, 5213, 1050, 1, 0, 0, 0, 5214, 5215, + 7, 26, 0, 0, 5215, 1052, 1, 0, 0, 0, 5216, 5217, 7, 27, 0, 0, 5217, 1054, + 1, 0, 0, 0, 5218, 5219, 7, 28, 0, 0, 5219, 1056, 1, 0, 0, 0, 5220, 5221, + 7, 29, 0, 0, 5221, 1058, 1, 0, 0, 0, 5222, 5223, 7, 30, 0, 0, 5223, 1060, + 1, 0, 0, 0, 5224, 5225, 7, 31, 0, 0, 5225, 1062, 1, 0, 0, 0, 5226, 5227, + 7, 32, 0, 0, 5227, 1064, 1, 0, 0, 0, 5228, 5229, 7, 33, 0, 0, 5229, 1066, + 1, 0, 0, 0, 5230, 5231, 7, 34, 0, 0, 5231, 1068, 1, 0, 0, 0, 46, 0, 1072, + 1083, 1095, 1109, 1119, 1127, 1139, 1152, 1167, 1180, 1192, 1222, 1235, + 1249, 1257, 1312, 1323, 1331, 1340, 1404, 1415, 1422, 1429, 1487, 1777, + 4995, 5067, 5079, 5081, 5092, 5099, 5104, 5110, 5112, 5116, 5121, 5123, + 5129, 5135, 5142, 5148, 5153, 5160, 5168, 5172, 1, 6, 0, 0, } deserializer := antlr.NewATNDeserializer(nil) staticData.atn = deserializer.Deserialize(staticData.serializedATN) @@ -3030,184 +3150,205 @@ const ( MDLLexerEXPRESSION = 302 MDLLexerXPATH = 303 MDLLexerCONSTRAINT = 304 - MDLLexerREST = 305 - MDLLexerSERVICE = 306 - MDLLexerSERVICES = 307 - MDLLexerODATA = 308 - MDLLexerBASE = 309 - MDLLexerAUTH = 310 - MDLLexerAUTHENTICATION = 311 - MDLLexerBASIC = 312 - MDLLexerNOTHING = 313 - MDLLexerOAUTH = 314 - MDLLexerOPERATION = 315 - MDLLexerMETHOD = 316 - MDLLexerPATH = 317 - MDLLexerTIMEOUT = 318 - MDLLexerBODY = 319 - MDLLexerRESPONSE = 320 - MDLLexerREQUEST = 321 - MDLLexerJSON = 322 - MDLLexerXML = 323 - MDLLexerSTATUS = 324 - MDLLexerVERSION = 325 - MDLLexerGET = 326 - MDLLexerPOST = 327 - MDLLexerPUT = 328 - MDLLexerPATCH = 329 - MDLLexerAPI = 330 - MDLLexerCLIENT = 331 - MDLLexerCLIENTS = 332 - MDLLexerPUBLISH = 333 - MDLLexerEXPOSE = 334 - MDLLexerNAMESPACE_KW = 335 - MDLLexerSESSION = 336 - MDLLexerGUEST = 337 - MDLLexerPAGING = 338 - MDLLexerNOT_SUPPORTED = 339 - MDLLexerUSERNAME = 340 - MDLLexerPASSWORD = 341 - MDLLexerCONNECTION = 342 - MDLLexerDATABASE = 343 - MDLLexerQUERY = 344 - MDLLexerMAP = 345 - MDLLexerMAPPING = 346 - MDLLexerIMPORT = 347 - MDLLexerINTO = 348 - MDLLexerBATCH = 349 - MDLLexerLINK = 350 - MDLLexerEXPORT = 351 - MDLLexerGENERATE = 352 - MDLLexerCONNECTOR = 353 - MDLLexerEXEC = 354 - MDLLexerTABLES = 355 - MDLLexerVIEWS = 356 - MDLLexerEXPOSED = 357 - MDLLexerPARAMETER = 358 - MDLLexerPARAMETERS = 359 - MDLLexerHEADERS = 360 - MDLLexerNAVIGATION = 361 - MDLLexerMENU_KW = 362 - MDLLexerHOMES = 363 - MDLLexerHOME = 364 - MDLLexerLOGIN = 365 - MDLLexerFOUND = 366 - MDLLexerMODULES = 367 - MDLLexerENTITIES = 368 - MDLLexerASSOCIATIONS = 369 - MDLLexerMICROFLOWS = 370 - MDLLexerNANOFLOWS = 371 - MDLLexerWORKFLOWS = 372 - MDLLexerENUMERATIONS = 373 - MDLLexerCONSTANTS = 374 - MDLLexerCONNECTIONS = 375 - MDLLexerDEFINE = 376 - MDLLexerFRAGMENT = 377 - MDLLexerFRAGMENTS = 378 - MDLLexerINSERT = 379 - MDLLexerBEFORE = 380 - MDLLexerAFTER = 381 - MDLLexerUPDATE = 382 - MDLLexerREFRESH = 383 - MDLLexerCHECK = 384 - MDLLexerBUILD = 385 - MDLLexerEXECUTE = 386 - MDLLexerSCRIPT = 387 - MDLLexerLINT = 388 - MDLLexerRULES = 389 - MDLLexerTEXT = 390 - MDLLexerSARIF = 391 - MDLLexerMESSAGE = 392 - MDLLexerCOMMENT = 393 - MDLLexerCATALOG = 394 - MDLLexerFORCE = 395 - MDLLexerBACKGROUND = 396 - MDLLexerCALLERS = 397 - MDLLexerCALLEES = 398 - MDLLexerREFERENCES = 399 - MDLLexerTRANSITIVE = 400 - MDLLexerIMPACT = 401 - MDLLexerDEPTH = 402 - MDLLexerSTRUCTURE = 403 - MDLLexerTYPE = 404 - MDLLexerVALUE = 405 - MDLLexerSINGLE = 406 - MDLLexerMULTIPLE = 407 - MDLLexerNONE = 408 - MDLLexerBOTH = 409 - MDLLexerTO = 410 - MDLLexerOF = 411 - MDLLexerOVER = 412 - MDLLexerFOR = 413 - MDLLexerREPLACE = 414 - MDLLexerMEMBERS = 415 - MDLLexerATTRIBUTE_NAME = 416 - MDLLexerFORMAT = 417 - MDLLexerSQL = 418 - MDLLexerWITHOUT = 419 - MDLLexerDRY = 420 - MDLLexerRUN = 421 - MDLLexerWIDGETTYPE = 422 - MDLLexerV3 = 423 - MDLLexerBUSINESS = 424 - MDLLexerEVENT = 425 - MDLLexerSUBSCRIBE = 426 - MDLLexerSETTINGS = 427 - MDLLexerCONFIGURATION = 428 - MDLLexerSECURITY = 429 - MDLLexerROLE = 430 - MDLLexerROLES = 431 - MDLLexerGRANT = 432 - MDLLexerREVOKE = 433 - MDLLexerPRODUCTION = 434 - MDLLexerPROTOTYPE = 435 - MDLLexerMANAGE = 436 - MDLLexerDEMO = 437 - MDLLexerMATRIX = 438 - MDLLexerAPPLY = 439 - MDLLexerACCESS = 440 - MDLLexerLEVEL = 441 - MDLLexerUSER = 442 - MDLLexerREAD = 443 - MDLLexerWRITE = 444 - MDLLexerDESCRIPTION = 445 - MDLLexerOFF = 446 - MDLLexerUSERS = 447 - MDLLexerNOT_EQUALS = 448 - MDLLexerLESS_THAN_OR_EQUAL = 449 - MDLLexerGREATER_THAN_OR_EQUAL = 450 - MDLLexerEQUALS = 451 - MDLLexerLESS_THAN = 452 - MDLLexerGREATER_THAN = 453 - MDLLexerPLUS = 454 - MDLLexerMINUS = 455 - MDLLexerSTAR = 456 - MDLLexerSLASH = 457 - MDLLexerPERCENT = 458 - MDLLexerMOD = 459 - MDLLexerDIV = 460 - MDLLexerSEMICOLON = 461 - MDLLexerCOMMA = 462 - MDLLexerDOT = 463 - MDLLexerLPAREN = 464 - MDLLexerRPAREN = 465 - MDLLexerLBRACE = 466 - MDLLexerRBRACE = 467 - MDLLexerLBRACKET = 468 - MDLLexerRBRACKET = 469 - MDLLexerCOLON = 470 - MDLLexerAT = 471 - MDLLexerPIPE = 472 - MDLLexerDOUBLE_COLON = 473 - MDLLexerARROW = 474 - MDLLexerQUESTION = 475 - MDLLexerHASH = 476 - MDLLexerMENDIX_TOKEN = 477 - MDLLexerSTRING_LITERAL = 478 - MDLLexerDOLLAR_STRING = 479 - MDLLexerNUMBER_LITERAL = 480 - MDLLexerVARIABLE = 481 - MDLLexerIDENTIFIER = 482 - MDLLexerHYPHENATED_ID = 483 - MDLLexerQUOTED_IDENTIFIER = 484 + MDLLexerCALCULATED = 305 + MDLLexerREST = 306 + MDLLexerSERVICE = 307 + MDLLexerSERVICES = 308 + MDLLexerODATA = 309 + MDLLexerBASE = 310 + MDLLexerAUTH = 311 + MDLLexerAUTHENTICATION = 312 + MDLLexerBASIC = 313 + MDLLexerNOTHING = 314 + MDLLexerOAUTH = 315 + MDLLexerOPERATION = 316 + MDLLexerMETHOD = 317 + MDLLexerPATH = 318 + MDLLexerTIMEOUT = 319 + MDLLexerBODY = 320 + MDLLexerRESPONSE = 321 + MDLLexerREQUEST = 322 + MDLLexerJSON = 323 + MDLLexerXML = 324 + MDLLexerSTATUS = 325 + MDLLexerVERSION = 326 + MDLLexerGET = 327 + MDLLexerPOST = 328 + MDLLexerPUT = 329 + MDLLexerPATCH = 330 + MDLLexerAPI = 331 + MDLLexerCLIENT = 332 + MDLLexerCLIENTS = 333 + MDLLexerPUBLISH = 334 + MDLLexerEXPOSE = 335 + MDLLexerNAMESPACE_KW = 336 + MDLLexerSESSION = 337 + MDLLexerGUEST = 338 + MDLLexerPAGING = 339 + MDLLexerNOT_SUPPORTED = 340 + MDLLexerUSERNAME = 341 + MDLLexerPASSWORD = 342 + MDLLexerCONNECTION = 343 + MDLLexerDATABASE = 344 + MDLLexerQUERY = 345 + MDLLexerMAP = 346 + MDLLexerMAPPING = 347 + MDLLexerIMPORT = 348 + MDLLexerINTO = 349 + MDLLexerBATCH = 350 + MDLLexerLINK = 351 + MDLLexerEXPORT = 352 + MDLLexerGENERATE = 353 + MDLLexerCONNECTOR = 354 + MDLLexerEXEC = 355 + MDLLexerTABLES = 356 + MDLLexerVIEWS = 357 + MDLLexerEXPOSED = 358 + MDLLexerPARAMETER = 359 + MDLLexerPARAMETERS = 360 + MDLLexerHEADERS = 361 + MDLLexerNAVIGATION = 362 + MDLLexerMENU_KW = 363 + MDLLexerHOMES = 364 + MDLLexerHOME = 365 + MDLLexerLOGIN = 366 + MDLLexerFOUND = 367 + MDLLexerMODULES = 368 + MDLLexerENTITIES = 369 + MDLLexerASSOCIATIONS = 370 + MDLLexerMICROFLOWS = 371 + MDLLexerNANOFLOWS = 372 + MDLLexerWORKFLOWS = 373 + MDLLexerENUMERATIONS = 374 + MDLLexerCONSTANTS = 375 + MDLLexerCONNECTIONS = 376 + MDLLexerDEFINE = 377 + MDLLexerFRAGMENT = 378 + MDLLexerFRAGMENTS = 379 + MDLLexerINSERT = 380 + MDLLexerBEFORE = 381 + MDLLexerAFTER = 382 + MDLLexerUPDATE = 383 + MDLLexerREFRESH = 384 + MDLLexerCHECK = 385 + MDLLexerBUILD = 386 + MDLLexerEXECUTE = 387 + MDLLexerSCRIPT = 388 + MDLLexerLINT = 389 + MDLLexerRULES = 390 + MDLLexerTEXT = 391 + MDLLexerSARIF = 392 + MDLLexerMESSAGE = 393 + MDLLexerCOMMENT = 394 + MDLLexerCATALOG = 395 + MDLLexerFORCE = 396 + MDLLexerBACKGROUND = 397 + MDLLexerCALLERS = 398 + MDLLexerCALLEES = 399 + MDLLexerREFERENCES = 400 + MDLLexerTRANSITIVE = 401 + MDLLexerIMPACT = 402 + MDLLexerDEPTH = 403 + MDLLexerSTRUCTURE = 404 + MDLLexerTYPE = 405 + MDLLexerVALUE = 406 + MDLLexerSINGLE = 407 + MDLLexerMULTIPLE = 408 + MDLLexerNONE = 409 + MDLLexerBOTH = 410 + MDLLexerTO = 411 + MDLLexerOF = 412 + MDLLexerOVER = 413 + MDLLexerFOR = 414 + MDLLexerREPLACE = 415 + MDLLexerMEMBERS = 416 + MDLLexerATTRIBUTE_NAME = 417 + MDLLexerFORMAT = 418 + MDLLexerSQL = 419 + MDLLexerWITHOUT = 420 + MDLLexerDRY = 421 + MDLLexerRUN = 422 + MDLLexerWIDGETTYPE = 423 + MDLLexerV3 = 424 + MDLLexerBUSINESS = 425 + MDLLexerEVENT = 426 + MDLLexerSUBSCRIBE = 427 + MDLLexerSETTINGS = 428 + MDLLexerCONFIGURATION = 429 + MDLLexerSECURITY = 430 + MDLLexerROLE = 431 + MDLLexerROLES = 432 + MDLLexerGRANT = 433 + MDLLexerREVOKE = 434 + MDLLexerPRODUCTION = 435 + MDLLexerPROTOTYPE = 436 + MDLLexerMANAGE = 437 + MDLLexerDEMO = 438 + MDLLexerMATRIX = 439 + MDLLexerAPPLY = 440 + MDLLexerACCESS = 441 + MDLLexerLEVEL = 442 + MDLLexerUSER = 443 + MDLLexerTASK = 444 + MDLLexerDECISION = 445 + MDLLexerSPLIT = 446 + MDLLexerOUTCOMES = 447 + MDLLexerTARGETING = 448 + MDLLexerNOTIFICATION = 449 + MDLLexerTIMER = 450 + MDLLexerJUMP = 451 + MDLLexerDUE = 452 + MDLLexerOVERVIEW = 453 + MDLLexerDATE = 454 + MDLLexerPARALLEL = 455 + MDLLexerWAIT = 456 + MDLLexerANNOTATION = 457 + MDLLexerBOUNDARY = 458 + MDLLexerINTERRUPTING = 459 + MDLLexerNON = 460 + MDLLexerMULTI = 461 + MDLLexerBY = 462 + MDLLexerREAD = 463 + MDLLexerWRITE = 464 + MDLLexerDESCRIPTION = 465 + MDLLexerDISPLAY = 466 + MDLLexerOFF = 467 + MDLLexerUSERS = 468 + MDLLexerNOT_EQUALS = 469 + MDLLexerLESS_THAN_OR_EQUAL = 470 + MDLLexerGREATER_THAN_OR_EQUAL = 471 + MDLLexerEQUALS = 472 + MDLLexerLESS_THAN = 473 + MDLLexerGREATER_THAN = 474 + MDLLexerPLUS = 475 + MDLLexerMINUS = 476 + MDLLexerSTAR = 477 + MDLLexerSLASH = 478 + MDLLexerPERCENT = 479 + MDLLexerMOD = 480 + MDLLexerDIV = 481 + MDLLexerSEMICOLON = 482 + MDLLexerCOMMA = 483 + MDLLexerDOT = 484 + MDLLexerLPAREN = 485 + MDLLexerRPAREN = 486 + MDLLexerLBRACE = 487 + MDLLexerRBRACE = 488 + MDLLexerLBRACKET = 489 + MDLLexerRBRACKET = 490 + MDLLexerCOLON = 491 + MDLLexerAT = 492 + MDLLexerPIPE = 493 + MDLLexerDOUBLE_COLON = 494 + MDLLexerARROW = 495 + MDLLexerQUESTION = 496 + MDLLexerHASH = 497 + MDLLexerMENDIX_TOKEN = 498 + MDLLexerSTRING_LITERAL = 499 + MDLLexerDOLLAR_STRING = 500 + MDLLexerNUMBER_LITERAL = 501 + MDLLexerVARIABLE = 502 + MDLLexerIDENTIFIER = 503 + MDLLexerHYPHENATED_ID = 504 + MDLLexerQUOTED_IDENTIFIER = 505 ) diff --git a/mdl/grammar/parser/mdl_parser.go b/mdl/grammar/parser/mdl_parser.go index 540552c..2da6c32 100644 --- a/mdl/grammar/parser/mdl_parser.go +++ b/mdl/grammar/parser/mdl_parser.go @@ -58,10 +58,11 @@ func mdlparserParserInit() { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", - "", "", "", "", "", "", "", "'<='", "'>='", "'='", "'<'", "'>'", "'+'", - "'-'", "'*'", "'/'", "'%'", "", "", "';'", "','", "'.'", "'('", "')'", - "'{'", "'}'", "'['", "']'", "':'", "'@'", "'|'", "'::'", "'->'", "'?'", - "'#'", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "'<='", "'>='", "'='", "'<'", + "'>'", "'+'", "'-'", "'*'", "'/'", "'%'", "", "", "';'", "','", "'.'", + "'('", "')'", "'{'", "'}'", "'['", "']'", "':'", "'@'", "'|'", "'::'", + "'->'", "'?'", "'#'", } staticData.SymbolicNames = []string{ "", "WS", "DOC_COMMENT", "BLOCK_COMMENT", "LINE_COMMENT", "IS_NOT_NULL", @@ -111,33 +112,35 @@ func mdlparserParserInit() { "OR", "NOT", "NULL", "IN", "BETWEEN", "LIKE", "MATCH", "EXISTS", "UNIQUE", "DEFAULT", "TRUE", "FALSE", "VALIDATION", "FEEDBACK", "RULE", "REQUIRED", "ERROR", "RAISE", "RANGE", "REGEX", "PATTERN", "EXPRESSION", "XPATH", - "CONSTRAINT", "REST", "SERVICE", "SERVICES", "ODATA", "BASE", "AUTH", - "AUTHENTICATION", "BASIC", "NOTHING", "OAUTH", "OPERATION", "METHOD", - "PATH", "TIMEOUT", "BODY", "RESPONSE", "REQUEST", "JSON", "XML", "STATUS", - "VERSION", "GET", "POST", "PUT", "PATCH", "API", "CLIENT", "CLIENTS", - "PUBLISH", "EXPOSE", "NAMESPACE_KW", "SESSION", "GUEST", "PAGING", "NOT_SUPPORTED", - "USERNAME", "PASSWORD", "CONNECTION", "DATABASE", "QUERY", "MAP", "MAPPING", - "IMPORT", "INTO", "BATCH", "LINK", "EXPORT", "GENERATE", "CONNECTOR", - "EXEC", "TABLES", "VIEWS", "EXPOSED", "PARAMETER", "PARAMETERS", "HEADERS", - "NAVIGATION", "MENU_KW", "HOMES", "HOME", "LOGIN", "FOUND", "MODULES", - "ENTITIES", "ASSOCIATIONS", "MICROFLOWS", "NANOFLOWS", "WORKFLOWS", - "ENUMERATIONS", "CONSTANTS", "CONNECTIONS", "DEFINE", "FRAGMENT", "FRAGMENTS", - "INSERT", "BEFORE", "AFTER", "UPDATE", "REFRESH", "CHECK", "BUILD", - "EXECUTE", "SCRIPT", "LINT", "RULES", "TEXT", "SARIF", "MESSAGE", "COMMENT", - "CATALOG", "FORCE", "BACKGROUND", "CALLERS", "CALLEES", "REFERENCES", + "CONSTRAINT", "CALCULATED", "REST", "SERVICE", "SERVICES", "ODATA", + "BASE", "AUTH", "AUTHENTICATION", "BASIC", "NOTHING", "OAUTH", "OPERATION", + "METHOD", "PATH", "TIMEOUT", "BODY", "RESPONSE", "REQUEST", "JSON", + "XML", "STATUS", "VERSION", "GET", "POST", "PUT", "PATCH", "API", "CLIENT", + "CLIENTS", "PUBLISH", "EXPOSE", "NAMESPACE_KW", "SESSION", "GUEST", + "PAGING", "NOT_SUPPORTED", "USERNAME", "PASSWORD", "CONNECTION", "DATABASE", + "QUERY", "MAP", "MAPPING", "IMPORT", "INTO", "BATCH", "LINK", "EXPORT", + "GENERATE", "CONNECTOR", "EXEC", "TABLES", "VIEWS", "EXPOSED", "PARAMETER", + "PARAMETERS", "HEADERS", "NAVIGATION", "MENU_KW", "HOMES", "HOME", "LOGIN", + "FOUND", "MODULES", "ENTITIES", "ASSOCIATIONS", "MICROFLOWS", "NANOFLOWS", + "WORKFLOWS", "ENUMERATIONS", "CONSTANTS", "CONNECTIONS", "DEFINE", "FRAGMENT", + "FRAGMENTS", "INSERT", "BEFORE", "AFTER", "UPDATE", "REFRESH", "CHECK", + "BUILD", "EXECUTE", "SCRIPT", "LINT", "RULES", "TEXT", "SARIF", "MESSAGE", + "COMMENT", "CATALOG", "FORCE", "BACKGROUND", "CALLERS", "CALLEES", "REFERENCES", "TRANSITIVE", "IMPACT", "DEPTH", "STRUCTURE", "TYPE", "VALUE", "SINGLE", "MULTIPLE", "NONE", "BOTH", "TO", "OF", "OVER", "FOR", "REPLACE", "MEMBERS", "ATTRIBUTE_NAME", "FORMAT", "SQL", "WITHOUT", "DRY", "RUN", "WIDGETTYPE", "V3", "BUSINESS", "EVENT", "SUBSCRIBE", "SETTINGS", "CONFIGURATION", "SECURITY", "ROLE", "ROLES", "GRANT", "REVOKE", "PRODUCTION", "PROTOTYPE", - "MANAGE", "DEMO", "MATRIX", "APPLY", "ACCESS", "LEVEL", "USER", "READ", - "WRITE", "DESCRIPTION", "OFF", "USERS", "NOT_EQUALS", "LESS_THAN_OR_EQUAL", - "GREATER_THAN_OR_EQUAL", "EQUALS", "LESS_THAN", "GREATER_THAN", "PLUS", - "MINUS", "STAR", "SLASH", "PERCENT", "MOD", "DIV", "SEMICOLON", "COMMA", - "DOT", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", - "COLON", "AT", "PIPE", "DOUBLE_COLON", "ARROW", "QUESTION", "HASH", - "MENDIX_TOKEN", "STRING_LITERAL", "DOLLAR_STRING", "NUMBER_LITERAL", - "VARIABLE", "IDENTIFIER", "HYPHENATED_ID", "QUOTED_IDENTIFIER", + "MANAGE", "DEMO", "MATRIX", "APPLY", "ACCESS", "LEVEL", "USER", "TASK", + "DECISION", "SPLIT", "OUTCOMES", "TARGETING", "NOTIFICATION", "TIMER", + "JUMP", "DUE", "OVERVIEW", "DATE", "PARALLEL", "WAIT", "ANNOTATION", + "BOUNDARY", "INTERRUPTING", "NON", "MULTI", "BY", "READ", "WRITE", "DESCRIPTION", + "DISPLAY", "OFF", "USERS", "NOT_EQUALS", "LESS_THAN_OR_EQUAL", "GREATER_THAN_OR_EQUAL", + "EQUALS", "LESS_THAN", "GREATER_THAN", "PLUS", "MINUS", "STAR", "SLASH", + "PERCENT", "MOD", "DIV", "SEMICOLON", "COMMA", "DOT", "LPAREN", "RPAREN", + "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "COLON", "AT", "PIPE", "DOUBLE_COLON", + "ARROW", "QUESTION", "HASH", "MENDIX_TOKEN", "STRING_LITERAL", "DOLLAR_STRING", + "NUMBER_LITERAL", "VARIABLE", "IDENTIFIER", "HYPHENATED_ID", "QUOTED_IDENTIFIER", } staticData.RuleNames = []string{ "program", "statement", "ddlStatement", "updateWidgetsStatement", "createStatement", @@ -148,7 +151,8 @@ func mdlparserParserInit() { "dropModuleRoleStatement", "createUserRoleStatement", "alterUserRoleStatement", "dropUserRoleStatement", "grantEntityAccessStatement", "revokeEntityAccessStatement", "grantMicroflowAccessStatement", "revokeMicroflowAccessStatement", "grantPageAccessStatement", - "revokePageAccessStatement", "grantODataServiceAccessStatement", "revokeODataServiceAccessStatement", + "revokePageAccessStatement", "grantWorkflowAccessStatement", "revokeWorkflowAccessStatement", + "grantODataServiceAccessStatement", "revokeODataServiceAccessStatement", "alterProjectSecurityStatement", "createDemoUserStatement", "dropDemoUserStatement", "updateSecurityStatement", "moduleRoleList", "entityAccessRightList", "entityAccessRight", "createEntityStatement", "generalizationClause", @@ -207,21 +211,26 @@ func mdlparserParserInit() { "exposeClause", "exposeMember", "exposeMemberOptions", "createExternalEntityStatement", "createNavigationStatement", "odataHeadersClause", "odataHeaderEntry", "createBusinessEventServiceStatement", "businessEventMessageDef", "businessEventAttrDef", - "alterSettingsClause", "settingsSection", "settingsAssignment", "settingsValue", - "dqlStatement", "showStatement", "showWidgetsFilter", "widgetTypeKeyword", - "widgetCondition", "widgetPropertyAssignment", "widgetPropertyValue", - "describeStatement", "catalogSelectQuery", "catalogJoinClause", "catalogTableName", - "oqlQuery", "oqlQueryTerm", "selectClause", "selectList", "selectItem", - "selectAlias", "fromClause", "tableReference", "joinClause", "associationPath", - "joinType", "whereClause", "groupByClause", "havingClause", "orderByClause", - "orderByList", "orderByItem", "groupByList", "limitOffsetClause", "utilityStatement", - "searchStatement", "connectStatement", "disconnectStatement", "updateStatement", - "checkStatement", "buildStatement", "executeScriptStatement", "executeRuntimeStatement", - "lintStatement", "lintTarget", "lintFormat", "useSessionStatement", - "sessionIdList", "sessionId", "introspectApiStatement", "debugStatement", - "sqlStatement", "sqlPassthrough", "importStatement", "importMapping", - "linkMapping", "helpStatement", "defineFragmentStatement", "expression", - "orExpression", "andExpression", "notExpression", "comparisonExpression", + "createWorkflowStatement", "workflowBody", "workflowActivityStmt", "workflowUserTaskStmt", + "workflowBoundaryEventClause", "workflowUserTaskOutcome", "workflowCallMicroflowStmt", + "workflowParameterMapping", "workflowCallWorkflowStmt", "workflowDecisionStmt", + "workflowConditionOutcome", "workflowParallelSplitStmt", "workflowParallelPath", + "workflowJumpToStmt", "workflowWaitForTimerStmt", "workflowWaitForNotificationStmt", + "workflowAnnotationStmt", "alterSettingsClause", "settingsSection", + "settingsAssignment", "settingsValue", "dqlStatement", "showStatement", + "showWidgetsFilter", "widgetTypeKeyword", "widgetCondition", "widgetPropertyAssignment", + "widgetPropertyValue", "describeStatement", "catalogSelectQuery", "catalogJoinClause", + "catalogTableName", "oqlQuery", "oqlQueryTerm", "selectClause", "selectList", + "selectItem", "selectAlias", "fromClause", "tableReference", "joinClause", + "associationPath", "joinType", "whereClause", "groupByClause", "havingClause", + "orderByClause", "orderByList", "orderByItem", "groupByList", "limitOffsetClause", + "utilityStatement", "searchStatement", "connectStatement", "disconnectStatement", + "updateStatement", "checkStatement", "buildStatement", "executeScriptStatement", + "executeRuntimeStatement", "lintStatement", "lintTarget", "lintFormat", + "useSessionStatement", "sessionIdList", "sessionId", "introspectApiStatement", + "debugStatement", "sqlStatement", "sqlPassthrough", "importStatement", + "importMapping", "linkMapping", "helpStatement", "defineFragmentStatement", + "expression", "orExpression", "andExpression", "notExpression", "comparisonExpression", "comparisonOperator", "additiveExpression", "multiplicativeExpression", "unaryExpression", "primaryExpression", "caseExpression", "castExpression", "castDataType", "aggregateFunction", "functionCall", "functionName", @@ -232,7 +241,7 @@ func mdlparserParserInit() { } staticData.PredictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ - 4, 1, 484, 5269, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 4, 1, 505, 5698, 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, @@ -303,2682 +312,2912 @@ func mdlparserParserInit() { 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, - 333, 2, 334, 7, 334, 2, 335, 7, 335, 1, 0, 5, 0, 674, 8, 0, 10, 0, 12, - 0, 677, 9, 0, 1, 0, 1, 0, 1, 1, 3, 1, 682, 8, 1, 1, 1, 1, 1, 1, 1, 3, 1, - 687, 8, 1, 1, 1, 3, 1, 690, 8, 1, 1, 1, 3, 1, 693, 8, 1, 1, 2, 1, 2, 1, - 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 702, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, - 3, 1, 3, 5, 3, 710, 8, 3, 10, 3, 12, 3, 713, 9, 3, 1, 3, 1, 3, 1, 3, 1, - 3, 5, 3, 719, 8, 3, 10, 3, 12, 3, 722, 9, 3, 1, 3, 1, 3, 1, 3, 3, 3, 727, - 8, 3, 3, 3, 729, 8, 3, 1, 3, 1, 3, 3, 3, 733, 8, 3, 1, 4, 3, 4, 736, 8, - 4, 1, 4, 5, 4, 739, 8, 4, 10, 4, 12, 4, 742, 9, 4, 1, 4, 1, 4, 1, 4, 3, - 4, 747, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, - 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 768, 8, - 4, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 774, 8, 5, 11, 5, 12, 5, 775, 1, 5, 1, - 5, 1, 5, 1, 5, 4, 5, 782, 8, 5, 11, 5, 12, 5, 783, 1, 5, 1, 5, 1, 5, 1, - 5, 4, 5, 790, 8, 5, 11, 5, 12, 5, 791, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 798, - 8, 5, 11, 5, 12, 5, 799, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, - 5, 5, 810, 8, 5, 10, 5, 12, 5, 813, 9, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, - 1, 5, 1, 5, 1, 5, 5, 5, 823, 8, 5, 10, 5, 12, 5, 826, 9, 5, 1, 5, 1, 5, - 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 836, 8, 5, 11, 5, 12, 5, 837, - 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 848, 8, 5, 11, 5, - 12, 5, 849, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 859, 8, 5, - 11, 5, 12, 5, 860, 1, 5, 1, 5, 3, 5, 865, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, - 5, 6, 871, 8, 6, 10, 6, 12, 6, 874, 9, 6, 1, 6, 1, 6, 1, 6, 3, 6, 879, - 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, - 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 896, 8, 7, 1, 8, 1, 8, 3, 8, 900, 8, 8, 1, - 8, 1, 8, 3, 8, 904, 8, 8, 1, 8, 1, 8, 3, 8, 908, 8, 8, 1, 8, 1, 8, 3, 8, - 912, 8, 8, 3, 8, 914, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, - 9, 1, 9, 1, 9, 5, 9, 926, 8, 9, 10, 9, 12, 9, 929, 9, 9, 1, 9, 1, 9, 1, - 9, 1, 9, 1, 9, 1, 9, 3, 9, 937, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, - 1, 10, 1, 10, 3, 10, 946, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, - 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 962, - 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 969, 8, 12, 10, 12, 12, - 12, 972, 9, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, - 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 986, 8, 14, 1, 14, 1, 14, 1, 14, 1, - 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 998, 8, 14, 10, 14, - 12, 14, 1001, 9, 14, 1, 14, 3, 14, 1004, 8, 14, 1, 15, 1, 15, 1, 15, 1, - 15, 1, 15, 1, 15, 1, 15, 3, 15, 1013, 8, 15, 1, 15, 3, 15, 1016, 8, 15, - 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1022, 8, 15, 10, 15, 12, 15, 1025, 9, - 15, 1, 15, 1, 15, 3, 15, 1029, 8, 15, 3, 15, 1031, 8, 15, 1, 16, 1, 16, - 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, + 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, + 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, + 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, + 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, + 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 1, 0, 5, 0, 712, 8, + 0, 10, 0, 12, 0, 715, 9, 0, 1, 0, 1, 0, 1, 1, 3, 1, 720, 8, 1, 1, 1, 1, + 1, 1, 1, 3, 1, 725, 8, 1, 1, 1, 3, 1, 728, 8, 1, 1, 1, 3, 1, 731, 8, 1, + 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 740, 8, 2, 1, 3, 1, 3, + 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 748, 8, 3, 10, 3, 12, 3, 751, 9, 3, 1, 3, + 1, 3, 1, 3, 1, 3, 5, 3, 757, 8, 3, 10, 3, 12, 3, 760, 9, 3, 1, 3, 1, 3, + 1, 3, 3, 3, 765, 8, 3, 3, 3, 767, 8, 3, 1, 3, 1, 3, 3, 3, 771, 8, 3, 1, + 4, 3, 4, 774, 8, 4, 1, 4, 5, 4, 777, 8, 4, 10, 4, 12, 4, 780, 9, 4, 1, + 4, 1, 4, 1, 4, 3, 4, 785, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 3, 4, 807, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 813, 8, 5, 11, + 5, 12, 5, 814, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 821, 8, 5, 11, 5, 12, 5, 822, + 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 829, 8, 5, 11, 5, 12, 5, 830, 1, 5, 1, 5, + 1, 5, 1, 5, 4, 5, 837, 8, 5, 11, 5, 12, 5, 838, 1, 5, 1, 5, 1, 5, 1, 5, + 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 849, 8, 5, 10, 5, 12, 5, 852, 9, 5, 1, 5, + 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 862, 8, 5, 10, 5, 12, 5, + 865, 9, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 875, 8, + 5, 11, 5, 12, 5, 876, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, + 5, 887, 8, 5, 11, 5, 12, 5, 888, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 4, 5, 898, 8, 5, 11, 5, 12, 5, 899, 1, 5, 1, 5, 3, 5, 904, 8, 5, 1, + 6, 1, 6, 1, 6, 1, 6, 5, 6, 910, 8, 6, 10, 6, 12, 6, 913, 9, 6, 1, 6, 1, + 6, 1, 6, 3, 6, 918, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, + 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 935, 8, 7, 1, 8, 1, + 8, 3, 8, 939, 8, 8, 1, 8, 1, 8, 3, 8, 943, 8, 8, 1, 8, 1, 8, 3, 8, 947, + 8, 8, 1, 8, 1, 8, 3, 8, 951, 8, 8, 3, 8, 953, 8, 8, 1, 9, 1, 9, 1, 9, 1, + 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 965, 8, 9, 10, 9, 12, 9, 968, + 9, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 976, 8, 9, 1, 10, 1, 10, + 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 985, 8, 10, 1, 11, 1, 11, 1, + 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, + 1, 11, 3, 11, 1001, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 1008, + 8, 12, 10, 12, 12, 12, 1011, 9, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, + 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1025, 8, 14, 1, + 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, + 1037, 8, 14, 10, 14, 12, 14, 1040, 9, 14, 1, 14, 3, 14, 1043, 8, 14, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1052, 8, 15, 1, 15, + 3, 15, 1055, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1061, 8, 15, 10, + 15, 12, 15, 1064, 9, 15, 1, 15, 1, 15, 3, 15, 1068, 8, 15, 3, 15, 1070, + 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, - 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1086, - 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, - 17, 1, 17, 3, 17, 1099, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, - 1, 18, 1, 18, 1, 18, 3, 18, 1110, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, - 18, 1, 18, 1, 18, 3, 18, 1119, 8, 18, 3, 18, 1121, 8, 18, 1, 18, 1, 18, - 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1132, 8, 18, 1, - 18, 1, 18, 1, 18, 1, 18, 3, 18, 1138, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, - 1, 18, 1, 18, 3, 18, 1146, 8, 18, 3, 18, 1148, 8, 18, 1, 19, 1, 19, 1, - 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, - 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1167, 8, 19, 1, 20, 1, 20, 1, 20, 1, - 20, 1, 20, 1, 20, 3, 20, 1175, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, - 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, - 22, 1192, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, + 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1128, 8, 16, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1141, 8, + 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, + 1152, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1161, + 8, 18, 3, 18, 1163, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 3, 18, 1174, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, + 1180, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1188, 8, + 18, 3, 18, 1190, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, + 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, + 19, 1, 19, 3, 19, 1211, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, + 3, 20, 1219, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 1236, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, - 23, 1, 23, 1, 23, 1, 23, 3, 23, 1216, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, - 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, - 25, 1232, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, - 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, - 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, - 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, - 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, - 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, - 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1300, 8, 33, 1, 34, 1, 34, - 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 1312, 8, - 34, 10, 34, 12, 34, 1315, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, - 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1328, 8, 36, 1, 37, 1, 37, - 1, 37, 5, 37, 1333, 8, 37, 10, 37, 12, 37, 1336, 9, 37, 1, 38, 1, 38, 1, - 38, 5, 38, 1341, 8, 38, 10, 38, 12, 38, 1344, 9, 38, 1, 39, 1, 39, 1, 39, - 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 5, 39, 1355, 8, 39, 10, 39, 12, - 39, 1358, 9, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, - 5, 39, 1368, 8, 39, 10, 39, 12, 39, 1371, 9, 39, 1, 39, 3, 39, 1374, 8, - 39, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1380, 8, 40, 1, 40, 3, 40, 1383, - 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1389, 8, 40, 1, 40, 3, 40, 1392, - 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1398, 8, 40, 1, 40, 1, 40, 3, - 40, 1402, 8, 40, 1, 40, 1, 40, 3, 40, 1406, 8, 40, 1, 40, 1, 40, 1, 40, - 1, 40, 3, 40, 1412, 8, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1417, 8, 40, 1, - 40, 3, 40, 1420, 8, 40, 3, 40, 1422, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, - 3, 41, 1428, 8, 41, 1, 42, 1, 42, 3, 42, 1432, 8, 42, 1, 42, 1, 42, 3, - 42, 1436, 8, 42, 1, 42, 3, 42, 1439, 8, 42, 1, 43, 1, 43, 3, 43, 1443, - 8, 43, 1, 43, 5, 43, 1446, 8, 43, 10, 43, 12, 43, 1449, 9, 43, 1, 44, 1, - 44, 1, 44, 1, 44, 3, 44, 1455, 8, 44, 1, 45, 1, 45, 1, 45, 5, 45, 1460, - 8, 45, 10, 45, 12, 45, 1463, 9, 45, 1, 46, 3, 46, 1466, 8, 46, 1, 46, 5, - 46, 1469, 8, 46, 10, 46, 12, 46, 1472, 9, 46, 1, 46, 1, 46, 1, 46, 1, 46, - 5, 46, 1478, 8, 46, 10, 46, 12, 46, 1481, 9, 46, 1, 47, 1, 47, 1, 47, 3, - 47, 1486, 8, 47, 1, 48, 1, 48, 1, 48, 3, 48, 1491, 8, 48, 1, 48, 1, 48, - 1, 48, 1, 48, 3, 48, 1497, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1502, 8, - 48, 1, 48, 1, 48, 1, 48, 3, 48, 1507, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, - 1512, 8, 48, 3, 48, 1514, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1520, - 8, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, - 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, - 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, - 49, 1552, 8, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1560, - 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, - 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, - 1581, 8, 51, 1, 52, 3, 52, 1584, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, - 53, 1, 53, 1, 53, 5, 53, 1593, 8, 53, 10, 53, 12, 53, 1596, 9, 53, 1, 54, - 1, 54, 3, 54, 1600, 8, 54, 1, 55, 1, 55, 1, 55, 3, 55, 1605, 8, 55, 1, - 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1614, 8, 56, 1, 57, - 4, 57, 1617, 8, 57, 11, 57, 12, 57, 1618, 1, 58, 1, 58, 1, 58, 1, 58, 1, - 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1631, 8, 58, 1, 59, 1, 59, - 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, - 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, - 1, 60, 1, 60, 5, 60, 1658, 8, 60, 10, 60, 12, 60, 1661, 9, 60, 1, 60, 1, - 60, 1, 60, 1, 60, 1, 60, 5, 60, 1668, 8, 60, 10, 60, 12, 60, 1671, 9, 60, - 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, - 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1691, 8, 60, - 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, - 61, 1, 61, 3, 61, 1705, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, - 1712, 8, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, - 62, 1, 62, 1, 62, 3, 62, 1725, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, - 3, 63, 1732, 8, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1740, - 8, 63, 1, 64, 1, 64, 1, 64, 3, 64, 1745, 8, 64, 1, 65, 4, 65, 1748, 8, - 65, 11, 65, 12, 65, 1749, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1756, 8, 66, - 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1764, 8, 67, 1, 68, 1, - 68, 1, 68, 5, 68, 1769, 8, 68, 10, 68, 12, 68, 1772, 9, 68, 1, 69, 3, 69, - 1775, 8, 69, 1, 69, 1, 69, 3, 69, 1779, 8, 69, 1, 69, 3, 69, 1782, 8, 69, - 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, - 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1799, 8, 70, 1, 71, 4, 71, 1802, - 8, 71, 11, 71, 12, 71, 1803, 1, 72, 1, 72, 1, 72, 1, 73, 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, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, - 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, - 74, 1843, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, - 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1858, 8, 75, 1, 76, 1, 76, 1, - 76, 5, 76, 1863, 8, 76, 10, 76, 12, 76, 1866, 9, 76, 1, 77, 1, 77, 1, 77, - 5, 77, 1871, 8, 77, 10, 77, 12, 77, 1874, 9, 77, 1, 78, 1, 78, 1, 78, 1, - 78, 3, 78, 1880, 8, 78, 1, 78, 1, 78, 3, 78, 1884, 8, 78, 1, 78, 3, 78, - 1887, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1893, 8, 78, 1, 78, 3, - 78, 1896, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1903, 8, 79, - 1, 79, 1, 79, 3, 79, 1907, 8, 79, 1, 79, 3, 79, 1910, 8, 79, 1, 79, 1, - 79, 1, 79, 3, 79, 1915, 8, 79, 1, 80, 1, 80, 1, 80, 5, 80, 1920, 8, 80, - 10, 80, 12, 80, 1923, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1929, 8, - 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, - 1, 84, 1, 84, 5, 84, 1943, 8, 84, 10, 84, 12, 84, 1946, 9, 84, 1, 85, 1, - 85, 3, 85, 1950, 8, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 3, 86, - 1958, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1964, 8, 87, 1, 88, 4, - 88, 1967, 8, 88, 11, 88, 12, 88, 1968, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, - 1975, 8, 89, 1, 90, 5, 90, 1978, 8, 90, 10, 90, 12, 90, 1981, 9, 90, 1, - 91, 5, 91, 1984, 8, 91, 10, 91, 12, 91, 1987, 9, 91, 1, 91, 1, 91, 3, 91, - 1991, 8, 91, 1, 91, 5, 91, 1994, 8, 91, 10, 91, 12, 91, 1997, 9, 91, 1, - 91, 1, 91, 3, 91, 2001, 8, 91, 1, 91, 5, 91, 2004, 8, 91, 10, 91, 12, 91, - 2007, 9, 91, 1, 91, 1, 91, 3, 91, 2011, 8, 91, 1, 91, 5, 91, 2014, 8, 91, - 10, 91, 12, 91, 2017, 9, 91, 1, 91, 1, 91, 3, 91, 2021, 8, 91, 1, 91, 5, - 91, 2024, 8, 91, 10, 91, 12, 91, 2027, 9, 91, 1, 91, 1, 91, 3, 91, 2031, - 8, 91, 1, 91, 5, 91, 2034, 8, 91, 10, 91, 12, 91, 2037, 9, 91, 1, 91, 1, - 91, 3, 91, 2041, 8, 91, 1, 91, 5, 91, 2044, 8, 91, 10, 91, 12, 91, 2047, - 9, 91, 1, 91, 1, 91, 3, 91, 2051, 8, 91, 1, 91, 5, 91, 2054, 8, 91, 10, - 91, 12, 91, 2057, 9, 91, 1, 91, 1, 91, 3, 91, 2061, 8, 91, 1, 91, 5, 91, - 2064, 8, 91, 10, 91, 12, 91, 2067, 9, 91, 1, 91, 1, 91, 3, 91, 2071, 8, - 91, 1, 91, 5, 91, 2074, 8, 91, 10, 91, 12, 91, 2077, 9, 91, 1, 91, 1, 91, - 3, 91, 2081, 8, 91, 1, 91, 5, 91, 2084, 8, 91, 10, 91, 12, 91, 2087, 9, - 91, 1, 91, 1, 91, 3, 91, 2091, 8, 91, 1, 91, 5, 91, 2094, 8, 91, 10, 91, - 12, 91, 2097, 9, 91, 1, 91, 1, 91, 3, 91, 2101, 8, 91, 1, 91, 5, 91, 2104, - 8, 91, 10, 91, 12, 91, 2107, 9, 91, 1, 91, 1, 91, 3, 91, 2111, 8, 91, 1, - 91, 5, 91, 2114, 8, 91, 10, 91, 12, 91, 2117, 9, 91, 1, 91, 1, 91, 3, 91, - 2121, 8, 91, 1, 91, 5, 91, 2124, 8, 91, 10, 91, 12, 91, 2127, 9, 91, 1, - 91, 1, 91, 3, 91, 2131, 8, 91, 1, 91, 5, 91, 2134, 8, 91, 10, 91, 12, 91, - 2137, 9, 91, 1, 91, 1, 91, 3, 91, 2141, 8, 91, 1, 91, 5, 91, 2144, 8, 91, - 10, 91, 12, 91, 2147, 9, 91, 1, 91, 1, 91, 3, 91, 2151, 8, 91, 1, 91, 5, - 91, 2154, 8, 91, 10, 91, 12, 91, 2157, 9, 91, 1, 91, 1, 91, 3, 91, 2161, - 8, 91, 1, 91, 5, 91, 2164, 8, 91, 10, 91, 12, 91, 2167, 9, 91, 1, 91, 1, - 91, 3, 91, 2171, 8, 91, 1, 91, 5, 91, 2174, 8, 91, 10, 91, 12, 91, 2177, - 9, 91, 1, 91, 1, 91, 3, 91, 2181, 8, 91, 1, 91, 5, 91, 2184, 8, 91, 10, - 91, 12, 91, 2187, 9, 91, 1, 91, 1, 91, 3, 91, 2191, 8, 91, 1, 91, 5, 91, - 2194, 8, 91, 10, 91, 12, 91, 2197, 9, 91, 1, 91, 1, 91, 3, 91, 2201, 8, - 91, 1, 91, 5, 91, 2204, 8, 91, 10, 91, 12, 91, 2207, 9, 91, 1, 91, 1, 91, - 3, 91, 2211, 8, 91, 1, 91, 5, 91, 2214, 8, 91, 10, 91, 12, 91, 2217, 9, - 91, 1, 91, 1, 91, 3, 91, 2221, 8, 91, 1, 91, 5, 91, 2224, 8, 91, 10, 91, - 12, 91, 2227, 9, 91, 1, 91, 1, 91, 3, 91, 2231, 8, 91, 1, 91, 5, 91, 2234, - 8, 91, 10, 91, 12, 91, 2237, 9, 91, 1, 91, 1, 91, 3, 91, 2241, 8, 91, 1, - 91, 5, 91, 2244, 8, 91, 10, 91, 12, 91, 2247, 9, 91, 1, 91, 1, 91, 3, 91, - 2251, 8, 91, 1, 91, 5, 91, 2254, 8, 91, 10, 91, 12, 91, 2257, 9, 91, 1, - 91, 1, 91, 3, 91, 2261, 8, 91, 1, 91, 5, 91, 2264, 8, 91, 10, 91, 12, 91, - 2267, 9, 91, 1, 91, 1, 91, 3, 91, 2271, 8, 91, 1, 91, 5, 91, 2274, 8, 91, - 10, 91, 12, 91, 2277, 9, 91, 1, 91, 1, 91, 3, 91, 2281, 8, 91, 1, 91, 5, - 91, 2284, 8, 91, 10, 91, 12, 91, 2287, 9, 91, 1, 91, 1, 91, 3, 91, 2291, - 8, 91, 1, 91, 5, 91, 2294, 8, 91, 10, 91, 12, 91, 2297, 9, 91, 1, 91, 1, - 91, 3, 91, 2301, 8, 91, 3, 91, 2303, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, - 1, 92, 3, 92, 2310, 8, 92, 1, 93, 1, 93, 1, 93, 3, 93, 2315, 8, 93, 1, - 93, 1, 93, 1, 93, 1, 94, 1, 94, 3, 94, 2322, 8, 94, 1, 94, 1, 94, 1, 94, - 1, 94, 3, 94, 2328, 8, 94, 1, 94, 3, 94, 2331, 8, 94, 1, 94, 3, 94, 2334, - 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 2340, 8, 95, 1, 95, 3, 95, 2343, - 8, 95, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2349, 8, 96, 4, 96, 2351, 8, - 96, 11, 96, 12, 96, 2352, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2359, 8, 97, - 1, 97, 3, 97, 2362, 8, 97, 1, 97, 3, 97, 2365, 8, 97, 1, 98, 1, 98, 1, - 98, 3, 98, 2370, 8, 98, 1, 99, 1, 99, 1, 99, 3, 99, 2375, 8, 99, 1, 100, - 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2384, 8, 100, 3, - 100, 2386, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2392, 8, 100, - 10, 100, 12, 100, 2395, 9, 100, 3, 100, 2397, 8, 100, 1, 100, 1, 100, 3, - 100, 2401, 8, 100, 1, 100, 1, 100, 3, 100, 2405, 8, 100, 1, 100, 3, 100, - 2408, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, - 101, 2417, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, - 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, - 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2439, 8, 102, 1, 103, 1, 103, 1, - 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 2450, 8, 103, - 10, 103, 12, 103, 2453, 9, 103, 1, 103, 1, 103, 3, 103, 2457, 8, 103, 1, - 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2467, - 8, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, - 3, 105, 2477, 8, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2482, 8, 105, 1, - 106, 1, 106, 1, 107, 1, 107, 1, 108, 1, 108, 3, 108, 2490, 8, 108, 1, 109, - 1, 109, 1, 109, 1, 110, 1, 110, 3, 110, 2497, 8, 110, 1, 110, 1, 110, 3, - 110, 2501, 8, 110, 1, 110, 1, 110, 3, 110, 2505, 8, 110, 1, 111, 1, 111, - 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 5, 112, 2514, 8, 112, 10, 112, - 12, 112, 2517, 9, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2523, 8, - 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, - 115, 1, 115, 1, 116, 1, 116, 3, 116, 2537, 8, 116, 1, 116, 1, 116, 1, 116, - 1, 116, 1, 116, 3, 116, 2544, 8, 116, 1, 116, 1, 116, 3, 116, 2548, 8, - 116, 1, 117, 1, 117, 3, 117, 2552, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, - 1, 117, 1, 117, 3, 117, 2560, 8, 117, 1, 117, 1, 117, 3, 117, 2564, 8, - 117, 1, 118, 1, 118, 3, 118, 2568, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, - 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2578, 8, 118, 3, 118, 2580, 8, - 118, 1, 118, 1, 118, 3, 118, 2584, 8, 118, 1, 118, 3, 118, 2587, 8, 118, - 1, 118, 1, 118, 1, 118, 3, 118, 2592, 8, 118, 1, 118, 3, 118, 2595, 8, - 118, 1, 118, 3, 118, 2598, 8, 118, 1, 119, 1, 119, 3, 119, 2602, 8, 119, - 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2610, 8, 119, 1, - 119, 1, 119, 3, 119, 2614, 8, 119, 1, 120, 1, 120, 1, 120, 5, 120, 2619, - 8, 120, 10, 120, 12, 120, 2622, 9, 120, 1, 121, 1, 121, 3, 121, 2626, 8, - 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, - 122, 2636, 8, 122, 1, 122, 3, 122, 2639, 8, 122, 1, 122, 1, 122, 3, 122, - 2643, 8, 122, 1, 122, 1, 122, 3, 122, 2647, 8, 122, 1, 123, 1, 123, 1, - 123, 5, 123, 2652, 8, 123, 10, 123, 12, 123, 2655, 9, 123, 1, 124, 1, 124, - 1, 124, 1, 124, 3, 124, 2661, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, - 124, 2667, 8, 124, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, - 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2681, 8, 127, 1, 127, 1, - 127, 1, 127, 1, 127, 1, 127, 3, 127, 2688, 8, 127, 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, 129, 3, 129, 2703, 8, 129, 1, 130, 1, 130, 3, 130, 2707, 8, 130, 1, - 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2714, 8, 130, 1, 130, 5, 130, - 2717, 8, 130, 10, 130, 12, 130, 2720, 9, 130, 1, 130, 3, 130, 2723, 8, - 130, 1, 130, 3, 130, 2726, 8, 130, 1, 130, 3, 130, 2729, 8, 130, 1, 130, - 1, 130, 3, 130, 2733, 8, 130, 1, 131, 1, 131, 1, 132, 1, 132, 3, 132, 2739, - 8, 132, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, - 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 3, 136, - 2757, 8, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2762, 8, 136, 1, 136, 1, - 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2770, 8, 136, 1, 137, 1, 137, - 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, - 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 2789, 8, 138, 1, - 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, - 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, - 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, - 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, - 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, - 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, - 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, - 140, 2854, 8, 140, 1, 141, 1, 141, 1, 141, 5, 141, 2859, 8, 141, 10, 141, - 12, 141, 2862, 9, 141, 1, 142, 1, 142, 3, 142, 2866, 8, 142, 1, 143, 1, - 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, - 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, - 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, - 144, 2896, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, - 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, - 1, 148, 1, 148, 1, 148, 5, 148, 2917, 8, 148, 10, 148, 12, 148, 2920, 9, - 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 3, - 150, 2930, 8, 150, 1, 151, 1, 151, 1, 151, 5, 151, 2935, 8, 151, 10, 151, - 12, 151, 2938, 9, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, - 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 3, 154, - 2954, 8, 154, 1, 154, 3, 154, 2957, 8, 154, 1, 154, 1, 154, 1, 154, 1, - 154, 1, 155, 4, 155, 2964, 8, 155, 11, 155, 12, 155, 2965, 1, 156, 1, 156, - 1, 156, 1, 157, 1, 157, 1, 157, 5, 157, 2974, 8, 157, 10, 157, 12, 157, - 2977, 9, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 5, - 159, 2986, 8, 159, 10, 159, 12, 159, 2989, 9, 159, 1, 160, 1, 160, 1, 160, - 1, 160, 1, 161, 1, 161, 1, 161, 5, 161, 2998, 8, 161, 10, 161, 12, 161, - 3001, 9, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, - 163, 3, 163, 3011, 8, 163, 1, 163, 3, 163, 3014, 8, 163, 1, 164, 1, 164, - 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 5, 166, 3025, 8, - 166, 10, 166, 12, 166, 3028, 9, 166, 1, 167, 1, 167, 1, 167, 5, 167, 3033, - 8, 167, 10, 167, 12, 167, 3036, 9, 167, 1, 168, 1, 168, 1, 168, 3, 168, - 3041, 8, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 3047, 8, 169, 1, - 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3055, 8, 170, 1, 171, - 1, 171, 1, 171, 5, 171, 3060, 8, 171, 10, 171, 12, 171, 3063, 9, 171, 1, - 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 3070, 8, 172, 1, 173, 1, 173, - 1, 173, 1, 173, 1, 173, 3, 173, 3077, 8, 173, 1, 174, 1, 174, 1, 174, 5, - 174, 3082, 8, 174, 10, 174, 12, 174, 3085, 9, 174, 1, 175, 1, 175, 1, 176, - 1, 176, 1, 176, 1, 176, 1, 176, 5, 176, 3094, 8, 176, 10, 176, 12, 176, - 3097, 9, 176, 3, 176, 3099, 8, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, - 178, 1, 178, 1, 178, 1, 178, 5, 178, 3109, 8, 178, 10, 178, 12, 178, 3112, - 9, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, - 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, - 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 3135, 8, 179, 1, 179, 1, 179, 1, - 179, 1, 179, 1, 179, 1, 179, 3, 179, 3143, 8, 179, 1, 180, 1, 180, 1, 180, - 1, 180, 5, 180, 3149, 8, 180, 10, 180, 12, 180, 3152, 9, 180, 1, 180, 1, + 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, + 1, 23, 3, 23, 1260, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, + 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1276, 8, 25, + 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, + 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, + 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, + 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, + 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, + 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, + 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1360, + 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1370, + 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 1376, 8, 36, 10, 36, 12, 36, + 1379, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, + 38, 1, 38, 1, 38, 3, 38, 1392, 8, 38, 1, 39, 1, 39, 1, 39, 5, 39, 1397, + 8, 39, 10, 39, 12, 39, 1400, 9, 39, 1, 40, 1, 40, 1, 40, 5, 40, 1405, 8, + 40, 10, 40, 12, 40, 1408, 9, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, + 41, 1, 41, 1, 41, 1, 41, 5, 41, 1419, 8, 41, 10, 41, 12, 41, 1422, 9, 41, + 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 1432, 8, + 41, 10, 41, 12, 41, 1435, 9, 41, 1, 41, 3, 41, 1438, 8, 41, 1, 42, 1, 42, + 1, 42, 1, 42, 3, 42, 1444, 8, 42, 1, 42, 3, 42, 1447, 8, 42, 1, 42, 1, + 42, 1, 42, 1, 42, 3, 42, 1453, 8, 42, 1, 42, 3, 42, 1456, 8, 42, 1, 42, + 1, 42, 1, 42, 1, 42, 3, 42, 1462, 8, 42, 1, 42, 1, 42, 3, 42, 1466, 8, + 42, 1, 42, 1, 42, 3, 42, 1470, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, + 1476, 8, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1481, 8, 42, 1, 42, 3, 42, 1484, + 8, 42, 3, 42, 1486, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 1492, 8, + 43, 1, 44, 1, 44, 3, 44, 1496, 8, 44, 1, 44, 1, 44, 3, 44, 1500, 8, 44, + 1, 44, 3, 44, 1503, 8, 44, 1, 45, 1, 45, 3, 45, 1507, 8, 45, 1, 45, 5, + 45, 1510, 8, 45, 10, 45, 12, 45, 1513, 9, 45, 1, 46, 1, 46, 1, 46, 1, 46, + 3, 46, 1519, 8, 46, 1, 47, 1, 47, 1, 47, 5, 47, 1524, 8, 47, 10, 47, 12, + 47, 1527, 9, 47, 1, 48, 3, 48, 1530, 8, 48, 1, 48, 5, 48, 1533, 8, 48, + 10, 48, 12, 48, 1536, 9, 48, 1, 48, 1, 48, 1, 48, 1, 48, 5, 48, 1542, 8, + 48, 10, 48, 12, 48, 1545, 9, 48, 1, 49, 1, 49, 1, 49, 3, 49, 1550, 8, 49, + 1, 50, 1, 50, 1, 50, 3, 50, 1555, 8, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, + 50, 1561, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1566, 8, 50, 1, 50, 1, 50, + 1, 50, 3, 50, 1571, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1576, 8, 50, 1, + 50, 1, 50, 3, 50, 1580, 8, 50, 1, 50, 3, 50, 1583, 8, 50, 3, 50, 1585, + 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1591, 8, 51, 1, 51, 1, 51, 1, + 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, + 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, + 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1623, 8, 51, 1, 52, + 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1631, 8, 53, 1, 53, 1, 53, 1, + 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, + 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1652, 8, 53, 1, 54, 3, + 54, 1655, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 5, 55, + 1664, 8, 55, 10, 55, 12, 55, 1667, 9, 55, 1, 56, 1, 56, 3, 56, 1671, 8, + 56, 1, 57, 1, 57, 1, 57, 3, 57, 1676, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, + 1, 58, 1, 58, 1, 58, 3, 58, 1685, 8, 58, 1, 59, 4, 59, 1688, 8, 59, 11, + 59, 12, 59, 1689, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, + 1, 60, 1, 60, 3, 60, 1702, 8, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, + 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 1729, + 8, 62, 10, 62, 12, 62, 1732, 9, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, + 5, 62, 1739, 8, 62, 10, 62, 12, 62, 1742, 9, 62, 1, 62, 1, 62, 1, 62, 1, + 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1762, 8, 62, 1, 63, 1, 63, 1, 63, 1, + 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1776, + 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1783, 8, 64, 1, 64, 1, + 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, + 1796, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1803, 8, 65, 1, + 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1811, 8, 65, 1, 66, 1, 66, + 1, 66, 3, 66, 1816, 8, 66, 1, 67, 4, 67, 1819, 8, 67, 11, 67, 12, 67, 1820, + 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1827, 8, 68, 1, 69, 1, 69, 1, 69, 1, + 69, 1, 69, 1, 69, 3, 69, 1835, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 1840, + 8, 70, 10, 70, 12, 70, 1843, 9, 70, 1, 71, 3, 71, 1846, 8, 71, 1, 71, 1, + 71, 3, 71, 1850, 8, 71, 1, 71, 3, 71, 1853, 8, 71, 1, 72, 1, 72, 1, 72, + 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, + 72, 1, 72, 3, 72, 1870, 8, 72, 1, 73, 4, 73, 1873, 8, 73, 11, 73, 12, 73, + 1874, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, + 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, + 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, + 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1914, 8, 76, 1, 77, + 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, + 77, 1, 77, 3, 77, 1929, 8, 77, 1, 78, 1, 78, 1, 78, 5, 78, 1934, 8, 78, + 10, 78, 12, 78, 1937, 9, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1942, 8, 79, 10, + 79, 12, 79, 1945, 9, 79, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1951, 8, 80, + 1, 80, 1, 80, 3, 80, 1955, 8, 80, 1, 80, 3, 80, 1958, 8, 80, 1, 80, 1, + 80, 1, 80, 1, 80, 3, 80, 1964, 8, 80, 1, 80, 3, 80, 1967, 8, 80, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1974, 8, 81, 1, 81, 1, 81, 3, 81, 1978, + 8, 81, 1, 81, 3, 81, 1981, 8, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1986, 8, + 81, 1, 82, 1, 82, 1, 82, 5, 82, 1991, 8, 82, 10, 82, 12, 82, 1994, 9, 82, + 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 2000, 8, 83, 1, 84, 1, 84, 1, 84, 1, + 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 5, 86, 2014, + 8, 86, 10, 86, 12, 86, 2017, 9, 86, 1, 87, 1, 87, 3, 87, 2021, 8, 87, 1, + 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 3, 88, 2029, 8, 88, 1, 89, 1, 89, + 1, 89, 1, 89, 3, 89, 2035, 8, 89, 1, 90, 4, 90, 2038, 8, 90, 11, 90, 12, + 90, 2039, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2046, 8, 91, 1, 92, 5, 92, + 2049, 8, 92, 10, 92, 12, 92, 2052, 9, 92, 1, 93, 5, 93, 2055, 8, 93, 10, + 93, 12, 93, 2058, 9, 93, 1, 93, 1, 93, 3, 93, 2062, 8, 93, 1, 93, 5, 93, + 2065, 8, 93, 10, 93, 12, 93, 2068, 9, 93, 1, 93, 1, 93, 3, 93, 2072, 8, + 93, 1, 93, 5, 93, 2075, 8, 93, 10, 93, 12, 93, 2078, 9, 93, 1, 93, 1, 93, + 3, 93, 2082, 8, 93, 1, 93, 5, 93, 2085, 8, 93, 10, 93, 12, 93, 2088, 9, + 93, 1, 93, 1, 93, 3, 93, 2092, 8, 93, 1, 93, 5, 93, 2095, 8, 93, 10, 93, + 12, 93, 2098, 9, 93, 1, 93, 1, 93, 3, 93, 2102, 8, 93, 1, 93, 5, 93, 2105, + 8, 93, 10, 93, 12, 93, 2108, 9, 93, 1, 93, 1, 93, 3, 93, 2112, 8, 93, 1, + 93, 5, 93, 2115, 8, 93, 10, 93, 12, 93, 2118, 9, 93, 1, 93, 1, 93, 3, 93, + 2122, 8, 93, 1, 93, 5, 93, 2125, 8, 93, 10, 93, 12, 93, 2128, 9, 93, 1, + 93, 1, 93, 3, 93, 2132, 8, 93, 1, 93, 5, 93, 2135, 8, 93, 10, 93, 12, 93, + 2138, 9, 93, 1, 93, 1, 93, 3, 93, 2142, 8, 93, 1, 93, 5, 93, 2145, 8, 93, + 10, 93, 12, 93, 2148, 9, 93, 1, 93, 1, 93, 3, 93, 2152, 8, 93, 1, 93, 5, + 93, 2155, 8, 93, 10, 93, 12, 93, 2158, 9, 93, 1, 93, 1, 93, 3, 93, 2162, + 8, 93, 1, 93, 5, 93, 2165, 8, 93, 10, 93, 12, 93, 2168, 9, 93, 1, 93, 1, + 93, 3, 93, 2172, 8, 93, 1, 93, 5, 93, 2175, 8, 93, 10, 93, 12, 93, 2178, + 9, 93, 1, 93, 1, 93, 3, 93, 2182, 8, 93, 1, 93, 5, 93, 2185, 8, 93, 10, + 93, 12, 93, 2188, 9, 93, 1, 93, 1, 93, 3, 93, 2192, 8, 93, 1, 93, 5, 93, + 2195, 8, 93, 10, 93, 12, 93, 2198, 9, 93, 1, 93, 1, 93, 3, 93, 2202, 8, + 93, 1, 93, 5, 93, 2205, 8, 93, 10, 93, 12, 93, 2208, 9, 93, 1, 93, 1, 93, + 3, 93, 2212, 8, 93, 1, 93, 5, 93, 2215, 8, 93, 10, 93, 12, 93, 2218, 9, + 93, 1, 93, 1, 93, 3, 93, 2222, 8, 93, 1, 93, 5, 93, 2225, 8, 93, 10, 93, + 12, 93, 2228, 9, 93, 1, 93, 1, 93, 3, 93, 2232, 8, 93, 1, 93, 5, 93, 2235, + 8, 93, 10, 93, 12, 93, 2238, 9, 93, 1, 93, 1, 93, 3, 93, 2242, 8, 93, 1, + 93, 5, 93, 2245, 8, 93, 10, 93, 12, 93, 2248, 9, 93, 1, 93, 1, 93, 3, 93, + 2252, 8, 93, 1, 93, 5, 93, 2255, 8, 93, 10, 93, 12, 93, 2258, 9, 93, 1, + 93, 1, 93, 3, 93, 2262, 8, 93, 1, 93, 5, 93, 2265, 8, 93, 10, 93, 12, 93, + 2268, 9, 93, 1, 93, 1, 93, 3, 93, 2272, 8, 93, 1, 93, 5, 93, 2275, 8, 93, + 10, 93, 12, 93, 2278, 9, 93, 1, 93, 1, 93, 3, 93, 2282, 8, 93, 1, 93, 5, + 93, 2285, 8, 93, 10, 93, 12, 93, 2288, 9, 93, 1, 93, 1, 93, 3, 93, 2292, + 8, 93, 1, 93, 5, 93, 2295, 8, 93, 10, 93, 12, 93, 2298, 9, 93, 1, 93, 1, + 93, 3, 93, 2302, 8, 93, 1, 93, 5, 93, 2305, 8, 93, 10, 93, 12, 93, 2308, + 9, 93, 1, 93, 1, 93, 3, 93, 2312, 8, 93, 1, 93, 5, 93, 2315, 8, 93, 10, + 93, 12, 93, 2318, 9, 93, 1, 93, 1, 93, 3, 93, 2322, 8, 93, 1, 93, 5, 93, + 2325, 8, 93, 10, 93, 12, 93, 2328, 9, 93, 1, 93, 1, 93, 3, 93, 2332, 8, + 93, 1, 93, 5, 93, 2335, 8, 93, 10, 93, 12, 93, 2338, 9, 93, 1, 93, 1, 93, + 3, 93, 2342, 8, 93, 1, 93, 5, 93, 2345, 8, 93, 10, 93, 12, 93, 2348, 9, + 93, 1, 93, 1, 93, 3, 93, 2352, 8, 93, 1, 93, 5, 93, 2355, 8, 93, 10, 93, + 12, 93, 2358, 9, 93, 1, 93, 1, 93, 3, 93, 2362, 8, 93, 1, 93, 5, 93, 2365, + 8, 93, 10, 93, 12, 93, 2368, 9, 93, 1, 93, 1, 93, 3, 93, 2372, 8, 93, 3, + 93, 2374, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2381, 8, 94, + 1, 95, 1, 95, 1, 95, 3, 95, 2386, 8, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, + 96, 3, 96, 2393, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2399, 8, 96, + 1, 96, 3, 96, 2402, 8, 96, 1, 96, 3, 96, 2405, 8, 96, 1, 97, 1, 97, 1, + 97, 1, 97, 3, 97, 2411, 8, 97, 1, 97, 3, 97, 2414, 8, 97, 1, 98, 1, 98, + 1, 98, 1, 98, 3, 98, 2420, 8, 98, 4, 98, 2422, 8, 98, 11, 98, 12, 98, 2423, + 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2430, 8, 99, 1, 99, 3, 99, 2433, 8, + 99, 1, 99, 3, 99, 2436, 8, 99, 1, 100, 1, 100, 1, 100, 3, 100, 2441, 8, + 100, 1, 101, 1, 101, 1, 101, 3, 101, 2446, 8, 101, 1, 102, 1, 102, 1, 102, + 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2455, 8, 102, 3, 102, 2457, 8, + 102, 1, 102, 1, 102, 1, 102, 1, 102, 5, 102, 2463, 8, 102, 10, 102, 12, + 102, 2466, 9, 102, 3, 102, 2468, 8, 102, 1, 102, 1, 102, 3, 102, 2472, + 8, 102, 1, 102, 1, 102, 3, 102, 2476, 8, 102, 1, 102, 3, 102, 2479, 8, + 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2488, + 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, + 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, + 1, 104, 1, 104, 1, 104, 3, 104, 2510, 8, 104, 1, 105, 1, 105, 1, 105, 1, + 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2521, 8, 105, 10, + 105, 12, 105, 2524, 9, 105, 1, 105, 1, 105, 3, 105, 2528, 8, 105, 1, 105, + 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2538, 8, + 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 3, + 107, 2548, 8, 107, 1, 107, 1, 107, 1, 107, 3, 107, 2553, 8, 107, 1, 108, + 1, 108, 1, 109, 1, 109, 1, 110, 1, 110, 3, 110, 2561, 8, 110, 1, 111, 1, + 111, 1, 111, 1, 112, 1, 112, 3, 112, 2568, 8, 112, 1, 112, 1, 112, 3, 112, + 2572, 8, 112, 1, 112, 1, 112, 3, 112, 2576, 8, 112, 1, 113, 1, 113, 1, + 114, 1, 114, 1, 114, 1, 114, 1, 114, 5, 114, 2585, 8, 114, 10, 114, 12, + 114, 2588, 9, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2594, 8, 114, + 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 117, + 1, 117, 1, 118, 1, 118, 3, 118, 2608, 8, 118, 1, 118, 1, 118, 1, 118, 1, + 118, 1, 118, 3, 118, 2615, 8, 118, 1, 118, 1, 118, 3, 118, 2619, 8, 118, + 1, 119, 1, 119, 3, 119, 2623, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, + 119, 1, 119, 3, 119, 2631, 8, 119, 1, 119, 1, 119, 3, 119, 2635, 8, 119, + 1, 120, 1, 120, 3, 120, 2639, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, + 120, 1, 120, 1, 120, 1, 120, 3, 120, 2649, 8, 120, 3, 120, 2651, 8, 120, + 1, 120, 1, 120, 3, 120, 2655, 8, 120, 1, 120, 3, 120, 2658, 8, 120, 1, + 120, 1, 120, 1, 120, 3, 120, 2663, 8, 120, 1, 120, 3, 120, 2666, 8, 120, + 1, 120, 3, 120, 2669, 8, 120, 1, 121, 1, 121, 3, 121, 2673, 8, 121, 1, + 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2681, 8, 121, 1, 121, + 1, 121, 3, 121, 2685, 8, 121, 1, 122, 1, 122, 1, 122, 5, 122, 2690, 8, + 122, 10, 122, 12, 122, 2693, 9, 122, 1, 123, 1, 123, 3, 123, 2697, 8, 123, + 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, + 2707, 8, 124, 1, 124, 3, 124, 2710, 8, 124, 1, 124, 1, 124, 3, 124, 2714, + 8, 124, 1, 124, 1, 124, 3, 124, 2718, 8, 124, 1, 125, 1, 125, 1, 125, 5, + 125, 2723, 8, 125, 10, 125, 12, 125, 2726, 9, 125, 1, 126, 1, 126, 1, 126, + 1, 126, 3, 126, 2732, 8, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2738, + 8, 126, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, + 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2752, 8, 129, 1, 129, 1, 129, 1, + 129, 1, 129, 1, 129, 3, 129, 2759, 8, 129, 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, 131, + 3, 131, 2774, 8, 131, 1, 132, 1, 132, 3, 132, 2778, 8, 132, 1, 132, 1, + 132, 1, 132, 1, 132, 1, 132, 3, 132, 2785, 8, 132, 1, 132, 5, 132, 2788, + 8, 132, 10, 132, 12, 132, 2791, 9, 132, 1, 132, 3, 132, 2794, 8, 132, 1, + 132, 3, 132, 2797, 8, 132, 1, 132, 3, 132, 2800, 8, 132, 1, 132, 1, 132, + 3, 132, 2804, 8, 132, 1, 133, 1, 133, 1, 134, 1, 134, 3, 134, 2810, 8, + 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, + 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 3, 138, 2828, + 8, 138, 1, 138, 1, 138, 1, 138, 3, 138, 2833, 8, 138, 1, 138, 1, 138, 1, + 138, 1, 138, 1, 138, 1, 138, 3, 138, 2841, 8, 138, 1, 139, 1, 139, 1, 139, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 2860, 8, 140, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 2925, + 8, 142, 1, 143, 1, 143, 1, 143, 5, 143, 2930, 8, 143, 10, 143, 12, 143, + 2933, 9, 143, 1, 144, 1, 144, 3, 144, 2937, 8, 144, 1, 145, 1, 145, 1, + 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 2967, + 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, + 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, + 1, 150, 1, 150, 5, 150, 2988, 8, 150, 10, 150, 12, 150, 2991, 9, 150, 1, + 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3001, + 8, 152, 1, 153, 1, 153, 1, 153, 5, 153, 3006, 8, 153, 10, 153, 12, 153, + 3009, 9, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, + 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 3, 156, 3025, 8, 156, + 1, 156, 3, 156, 3028, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 4, + 157, 3035, 8, 157, 11, 157, 12, 157, 3036, 1, 158, 1, 158, 1, 158, 1, 159, + 1, 159, 1, 159, 5, 159, 3045, 8, 159, 10, 159, 12, 159, 3048, 9, 159, 1, + 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 5, 161, 3057, 8, 161, + 10, 161, 12, 161, 3060, 9, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, + 1, 163, 1, 163, 5, 163, 3069, 8, 163, 10, 163, 12, 163, 3072, 9, 163, 1, + 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 3, 165, 3082, + 8, 165, 1, 165, 3, 165, 3085, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, + 167, 1, 167, 1, 168, 1, 168, 1, 168, 5, 168, 3096, 8, 168, 10, 168, 12, + 168, 3099, 9, 168, 1, 169, 1, 169, 1, 169, 5, 169, 3104, 8, 169, 10, 169, + 12, 169, 3107, 9, 169, 1, 170, 1, 170, 1, 170, 3, 170, 3112, 8, 170, 1, + 171, 1, 171, 1, 171, 1, 171, 3, 171, 3118, 8, 171, 1, 172, 1, 172, 1, 172, + 1, 172, 1, 172, 1, 172, 3, 172, 3126, 8, 172, 1, 173, 1, 173, 1, 173, 5, + 173, 3131, 8, 173, 10, 173, 12, 173, 3134, 9, 173, 1, 174, 1, 174, 1, 174, + 1, 174, 1, 174, 3, 174, 3141, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, + 175, 3, 175, 3148, 8, 175, 1, 176, 1, 176, 1, 176, 5, 176, 3153, 8, 176, + 10, 176, 12, 176, 3156, 9, 176, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, + 1, 178, 1, 178, 5, 178, 3165, 8, 178, 10, 178, 12, 178, 3168, 9, 178, 3, + 178, 3170, 8, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, + 1, 180, 5, 180, 3180, 8, 180, 10, 180, 12, 180, 3183, 9, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, - 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3171, 8, 181, - 1, 182, 1, 182, 5, 182, 3175, 8, 182, 10, 182, 12, 182, 3178, 9, 182, 1, - 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 3185, 8, 183, 1, 184, 1, 184, - 1, 184, 3, 184, 3190, 8, 184, 1, 184, 3, 184, 3193, 8, 184, 1, 185, 1, - 185, 1, 186, 1, 186, 1, 186, 1, 186, 5, 186, 3201, 8, 186, 10, 186, 12, - 186, 3204, 9, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, - 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 3283, 8, - 187, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 5, 189, 3291, 8, 189, - 10, 189, 12, 189, 3294, 9, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, - 3, 190, 3301, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 5, - 190, 3309, 8, 190, 10, 190, 12, 190, 3312, 9, 190, 1, 190, 3, 190, 3315, - 8, 190, 3, 190, 3317, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 5, 190, 3323, - 8, 190, 10, 190, 12, 190, 3326, 9, 190, 3, 190, 3328, 8, 190, 1, 190, 1, - 190, 1, 190, 3, 190, 3333, 8, 190, 1, 190, 1, 190, 1, 190, 3, 190, 3338, - 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 3344, 8, 190, 1, 191, 1, - 191, 3, 191, 3348, 8, 191, 1, 191, 1, 191, 3, 191, 3352, 8, 191, 1, 191, - 1, 191, 1, 191, 1, 191, 3, 191, 3358, 8, 191, 1, 191, 1, 191, 1, 191, 1, - 191, 3, 191, 3364, 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3369, 8, 191, - 1, 191, 1, 191, 1, 191, 3, 191, 3374, 8, 191, 1, 191, 1, 191, 1, 191, 3, - 191, 3379, 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 3384, 8, 191, 1, 192, - 1, 192, 1, 192, 1, 192, 5, 192, 3390, 8, 192, 10, 192, 12, 192, 3393, 9, - 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, - 193, 3403, 8, 193, 1, 194, 1, 194, 1, 194, 3, 194, 3408, 8, 194, 1, 194, - 1, 194, 1, 194, 1, 194, 3, 194, 3414, 8, 194, 5, 194, 3416, 8, 194, 10, - 194, 12, 194, 3419, 9, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, - 195, 3, 195, 3427, 8, 195, 3, 195, 3429, 8, 195, 3, 195, 3431, 8, 195, - 1, 196, 1, 196, 1, 196, 1, 196, 5, 196, 3437, 8, 196, 10, 196, 12, 196, - 3440, 9, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, - 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, 1, 201, 1, - 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, - 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 5, 202, 3473, 8, 202, 10, - 202, 12, 202, 3476, 9, 202, 3, 202, 3478, 8, 202, 1, 202, 3, 202, 3481, - 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 5, 203, 3487, 8, 203, 10, 203, - 12, 203, 3490, 9, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 3496, 8, - 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, - 204, 3, 204, 3507, 8, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, - 1, 206, 3, 206, 3516, 8, 206, 1, 206, 1, 206, 5, 206, 3520, 8, 206, 10, - 206, 12, 206, 3523, 9, 206, 1, 206, 1, 206, 1, 207, 4, 207, 3528, 8, 207, - 11, 207, 12, 207, 3529, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, - 1, 209, 3, 209, 3539, 8, 209, 1, 210, 1, 210, 1, 210, 1, 210, 4, 210, 3545, - 8, 210, 11, 210, 12, 210, 3546, 1, 210, 1, 210, 5, 210, 3551, 8, 210, 10, - 210, 12, 210, 3554, 9, 210, 1, 210, 3, 210, 3557, 8, 210, 1, 211, 1, 211, - 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 3566, 8, 211, 1, 211, 1, - 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, - 211, 3578, 8, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 3584, 8, 211, - 3, 211, 3586, 8, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, - 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 3599, 8, 212, 5, 212, 3601, - 8, 212, 10, 212, 12, 212, 3604, 9, 212, 1, 212, 1, 212, 1, 212, 1, 212, - 1, 212, 1, 212, 1, 212, 5, 212, 3613, 8, 212, 10, 212, 12, 212, 3616, 9, - 212, 1, 212, 1, 212, 3, 212, 3620, 8, 212, 3, 212, 3622, 8, 212, 1, 212, - 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, - 1, 214, 1, 214, 1, 214, 3, 214, 3637, 8, 214, 1, 215, 4, 215, 3640, 8, - 215, 11, 215, 12, 215, 3641, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, - 217, 1, 217, 1, 217, 1, 217, 5, 217, 3653, 8, 217, 10, 217, 12, 217, 3656, - 9, 217, 1, 217, 1, 217, 1, 218, 4, 218, 3661, 8, 218, 11, 218, 12, 218, - 3662, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, - 219, 3, 219, 3674, 8, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, - 1, 220, 1, 220, 3, 220, 3684, 8, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, - 221, 1, 221, 1, 221, 3, 221, 3693, 8, 221, 1, 222, 1, 222, 1, 223, 4, 223, - 3698, 8, 223, 11, 223, 12, 223, 3699, 1, 224, 1, 224, 1, 224, 1, 224, 1, - 224, 1, 224, 1, 224, 1, 224, 3, 224, 3710, 8, 224, 1, 225, 1, 225, 1, 225, - 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 3721, 8, 226, 1, - 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, - 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 5, 228, 3738, 8, 228, 10, - 228, 12, 228, 3741, 9, 228, 1, 228, 1, 228, 3, 228, 3745, 8, 228, 1, 229, - 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 5, 229, 3754, 8, 229, 10, - 229, 12, 229, 3757, 9, 229, 1, 229, 1, 229, 3, 229, 3761, 8, 229, 1, 229, - 1, 229, 5, 229, 3765, 8, 229, 10, 229, 12, 229, 3768, 9, 229, 1, 229, 3, - 229, 3771, 8, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 3, 230, - 3779, 8, 230, 1, 230, 3, 230, 3782, 8, 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, 5, - 233, 3796, 8, 233, 10, 233, 12, 233, 3799, 9, 233, 1, 234, 1, 234, 1, 234, - 1, 234, 1, 234, 3, 234, 3806, 8, 234, 1, 234, 3, 234, 3809, 8, 234, 1, - 235, 1, 235, 1, 235, 1, 235, 1, 235, 3, 235, 3816, 8, 235, 1, 235, 1, 235, - 1, 235, 1, 235, 5, 235, 3822, 8, 235, 10, 235, 12, 235, 3825, 9, 235, 1, - 235, 1, 235, 3, 235, 3829, 8, 235, 1, 235, 3, 235, 3832, 8, 235, 1, 235, - 3, 235, 3835, 8, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 5, - 236, 3843, 8, 236, 10, 236, 12, 236, 3846, 9, 236, 3, 236, 3848, 8, 236, - 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 3, 237, 3855, 8, 237, 1, 237, 3, - 237, 3858, 8, 237, 1, 238, 1, 238, 1, 238, 1, 238, 5, 238, 3864, 8, 238, - 10, 238, 12, 238, 3867, 9, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, - 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 5, 239, - 3882, 8, 239, 10, 239, 12, 239, 3885, 9, 239, 1, 239, 1, 239, 1, 239, 3, - 239, 3890, 8, 239, 1, 239, 3, 239, 3893, 8, 239, 1, 240, 1, 240, 1, 240, - 3, 240, 3898, 8, 240, 1, 240, 5, 240, 3901, 8, 240, 10, 240, 12, 240, 3904, - 9, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 5, 241, 3911, 8, 241, 10, - 241, 12, 241, 3914, 9, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, - 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 5, - 243, 3930, 8, 243, 10, 243, 12, 243, 3933, 9, 243, 1, 243, 1, 243, 1, 243, - 4, 243, 3938, 8, 243, 11, 243, 12, 243, 3939, 1, 243, 1, 243, 1, 244, 1, - 244, 1, 244, 1, 244, 1, 244, 1, 244, 5, 244, 3950, 8, 244, 10, 244, 12, - 244, 3953, 9, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, 3959, 8, 244, - 1, 244, 1, 244, 3, 244, 3963, 8, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, - 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 5, 246, 3975, 8, 246, 10, - 246, 12, 246, 3978, 9, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, - 246, 1, 246, 3, 246, 3987, 8, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, - 5, 246, 3994, 8, 246, 10, 246, 12, 246, 3997, 9, 246, 3, 246, 3999, 8, - 246, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, - 249, 1, 249, 3, 249, 4011, 8, 249, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, - 4017, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, - 251, 4026, 8, 251, 3, 251, 4028, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 1, 251, 3, 251, 4035, 8, 251, 3, 251, 4037, 8, 251, 1, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 3, 251, 4044, 8, 251, 3, 251, 4046, 8, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4053, 8, 251, 3, 251, 4055, 8, - 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4062, 8, 251, 3, 251, - 4064, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4071, 8, - 251, 3, 251, 4073, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, - 4080, 8, 251, 3, 251, 4082, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, - 251, 3, 251, 4089, 8, 251, 3, 251, 4091, 8, 251, 1, 251, 1, 251, 1, 251, - 1, 251, 1, 251, 3, 251, 4098, 8, 251, 3, 251, 4100, 8, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 1, 251, 3, 251, 4107, 8, 251, 3, 251, 4109, 8, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4116, 8, 251, 3, 251, 4118, - 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4126, 8, - 251, 3, 251, 4128, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 1, 251, 1, 251, 3, 251, 4156, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, - 251, 3, 251, 4163, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, - 4179, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4184, 8, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4195, - 8, 251, 3, 251, 4197, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 3, 251, 4225, 8, 251, 3, 251, 4227, 8, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4235, 8, 251, 3, 251, 4237, - 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4245, 8, - 251, 3, 251, 4247, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 3, 251, 4255, 8, 251, 3, 251, 4257, 8, 251, 1, 251, 1, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 1, 251, 3, 251, 4266, 8, 251, 1, 251, 1, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4276, 8, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 3, 251, 4282, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, - 4287, 8, 251, 3, 251, 4289, 8, 251, 1, 251, 3, 251, 4292, 8, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4301, 8, 251, 3, - 251, 4303, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 3, 251, 4312, 8, 251, 3, 251, 4314, 8, 251, 1, 251, 1, 251, 1, 251, 1, - 251, 1, 251, 1, 251, 3, 251, 4322, 8, 251, 3, 251, 4324, 8, 251, 1, 251, - 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, - 3, 251, 4336, 8, 251, 3, 251, 4338, 8, 251, 3, 251, 4340, 8, 251, 1, 252, - 1, 252, 1, 252, 1, 252, 5, 252, 4346, 8, 252, 10, 252, 12, 252, 4349, 9, - 252, 1, 252, 1, 252, 1, 252, 3, 252, 4354, 8, 252, 3, 252, 4356, 8, 252, - 1, 252, 1, 252, 1, 252, 3, 252, 4361, 8, 252, 3, 252, 4363, 8, 252, 1, - 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 3, 254, 4373, - 8, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, - 3, 256, 4383, 8, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, - 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, - 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, - 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, - 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4424, 8, 257, 1, 257, - 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, - 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, - 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, - 3, 257, 4454, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, - 257, 3, 257, 4463, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, - 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, - 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, - 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, - 1, 257, 3, 257, 4499, 8, 257, 1, 258, 1, 258, 3, 258, 4503, 8, 258, 1, - 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 3, 258, 4511, 8, 258, 1, 258, - 3, 258, 4514, 8, 258, 1, 258, 5, 258, 4517, 8, 258, 10, 258, 12, 258, 4520, - 9, 258, 1, 258, 1, 258, 3, 258, 4524, 8, 258, 1, 258, 1, 258, 1, 258, 1, - 258, 3, 258, 4530, 8, 258, 3, 258, 4532, 8, 258, 1, 258, 1, 258, 3, 258, - 4536, 8, 258, 1, 258, 1, 258, 3, 258, 4540, 8, 258, 1, 258, 1, 258, 3, - 258, 4544, 8, 258, 1, 259, 3, 259, 4547, 8, 259, 1, 259, 1, 259, 1, 259, - 1, 259, 1, 259, 3, 259, 4554, 8, 259, 1, 259, 3, 259, 4557, 8, 259, 1, - 259, 1, 259, 3, 259, 4561, 8, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, - 3, 261, 4568, 8, 261, 1, 261, 5, 261, 4571, 8, 261, 10, 261, 12, 261, 4574, - 9, 261, 1, 262, 1, 262, 3, 262, 4578, 8, 262, 1, 262, 3, 262, 4581, 8, - 262, 1, 262, 3, 262, 4584, 8, 262, 1, 262, 3, 262, 4587, 8, 262, 1, 262, - 3, 262, 4590, 8, 262, 1, 262, 3, 262, 4593, 8, 262, 1, 262, 1, 262, 3, - 262, 4597, 8, 262, 1, 262, 3, 262, 4600, 8, 262, 1, 262, 3, 262, 4603, - 8, 262, 1, 262, 1, 262, 3, 262, 4607, 8, 262, 1, 262, 3, 262, 4610, 8, - 262, 3, 262, 4612, 8, 262, 1, 263, 1, 263, 3, 263, 4616, 8, 263, 1, 263, - 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 5, 264, 4624, 8, 264, 10, 264, - 12, 264, 4627, 9, 264, 3, 264, 4629, 8, 264, 1, 265, 1, 265, 1, 265, 3, - 265, 4634, 8, 265, 1, 265, 1, 265, 1, 265, 3, 265, 4639, 8, 265, 3, 265, - 4641, 8, 265, 1, 266, 1, 266, 3, 266, 4645, 8, 266, 1, 267, 1, 267, 1, - 267, 5, 267, 4650, 8, 267, 10, 267, 12, 267, 4653, 9, 267, 1, 268, 1, 268, - 3, 268, 4657, 8, 268, 1, 268, 3, 268, 4660, 8, 268, 1, 268, 1, 268, 1, - 268, 1, 268, 3, 268, 4666, 8, 268, 1, 268, 3, 268, 4669, 8, 268, 3, 268, - 4671, 8, 268, 1, 269, 3, 269, 4674, 8, 269, 1, 269, 1, 269, 1, 269, 1, - 269, 3, 269, 4680, 8, 269, 1, 269, 3, 269, 4683, 8, 269, 1, 269, 1, 269, - 1, 269, 3, 269, 4688, 8, 269, 1, 269, 3, 269, 4691, 8, 269, 3, 269, 4693, - 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, - 1, 270, 1, 270, 3, 270, 4705, 8, 270, 1, 271, 1, 271, 3, 271, 4709, 8, - 271, 1, 271, 1, 271, 3, 271, 4713, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, - 4718, 8, 271, 1, 271, 3, 271, 4721, 8, 271, 1, 272, 1, 272, 1, 272, 1, - 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, - 276, 1, 276, 1, 276, 5, 276, 4738, 8, 276, 10, 276, 12, 276, 4741, 9, 276, - 1, 277, 1, 277, 3, 277, 4745, 8, 277, 1, 278, 1, 278, 1, 278, 5, 278, 4750, - 8, 278, 10, 278, 12, 278, 4753, 9, 278, 1, 279, 1, 279, 1, 279, 1, 279, - 3, 279, 4759, 8, 279, 1, 279, 1, 279, 1, 279, 1, 279, 3, 279, 4765, 8, - 279, 3, 279, 4767, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, - 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, - 1, 280, 3, 280, 4785, 8, 280, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, - 282, 1, 282, 1, 282, 1, 282, 3, 282, 4796, 8, 282, 1, 282, 1, 282, 1, 282, - 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, - 1, 282, 3, 282, 4811, 8, 282, 3, 282, 4813, 8, 282, 1, 283, 1, 283, 1, - 284, 1, 284, 1, 284, 1, 284, 3, 284, 4821, 8, 284, 1, 284, 3, 284, 4824, - 8, 284, 1, 284, 3, 284, 4827, 8, 284, 1, 284, 3, 284, 4830, 8, 284, 1, - 284, 3, 284, 4833, 8, 284, 1, 285, 1, 285, 1, 286, 1, 286, 1, 287, 1, 287, - 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 3, 289, - 4849, 8, 289, 1, 289, 1, 289, 3, 289, 4853, 8, 289, 1, 289, 1, 289, 1, - 289, 3, 289, 4858, 8, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, - 3, 290, 4866, 8, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 3, - 292, 4874, 8, 292, 1, 293, 1, 293, 1, 293, 5, 293, 4879, 8, 293, 10, 293, - 12, 293, 4882, 9, 293, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 296, - 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, - 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, - 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, - 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 5, 297, 4922, 8, 297, 10, 297, - 12, 297, 4925, 9, 297, 1, 297, 1, 297, 3, 297, 4929, 8, 297, 1, 297, 1, - 297, 1, 297, 1, 297, 1, 297, 5, 297, 4936, 8, 297, 10, 297, 12, 297, 4939, - 9, 297, 1, 297, 1, 297, 3, 297, 4943, 8, 297, 1, 297, 3, 297, 4946, 8, - 297, 1, 297, 1, 297, 1, 297, 3, 297, 4951, 8, 297, 1, 298, 4, 298, 4954, - 8, 298, 11, 298, 12, 298, 4955, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, - 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 5, 299, 4970, 8, - 299, 10, 299, 12, 299, 4973, 9, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, - 299, 1, 299, 5, 299, 4981, 8, 299, 10, 299, 12, 299, 4984, 9, 299, 1, 299, - 1, 299, 3, 299, 4988, 8, 299, 1, 299, 1, 299, 3, 299, 4992, 8, 299, 1, - 299, 1, 299, 3, 299, 4996, 8, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, - 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, - 3, 301, 5012, 8, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, - 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 5, - 305, 5029, 8, 305, 10, 305, 12, 305, 5032, 9, 305, 1, 306, 1, 306, 1, 306, - 5, 306, 5037, 8, 306, 10, 306, 12, 306, 5040, 9, 306, 1, 307, 3, 307, 5043, - 8, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, - 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5057, 8, 308, 1, 308, 1, 308, 1, - 308, 3, 308, 5062, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, - 3, 308, 5070, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5076, 8, - 308, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 5, 310, 5083, 8, 310, 10, - 310, 12, 310, 5086, 9, 310, 1, 311, 1, 311, 1, 311, 5, 311, 5091, 8, 311, - 10, 311, 12, 311, 5094, 9, 311, 1, 312, 3, 312, 5097, 8, 312, 1, 312, 1, - 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, - 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, - 313, 1, 313, 1, 313, 3, 313, 5121, 8, 313, 1, 314, 1, 314, 1, 314, 1, 314, - 1, 314, 1, 314, 4, 314, 5129, 8, 314, 11, 314, 12, 314, 5130, 1, 314, 1, - 314, 3, 314, 5135, 8, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, - 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 3, 317, - 5151, 8, 317, 1, 317, 1, 317, 3, 317, 5155, 8, 317, 1, 317, 1, 317, 1, - 318, 1, 318, 1, 318, 3, 318, 5162, 8, 318, 1, 318, 1, 318, 1, 319, 1, 319, - 1, 320, 1, 320, 1, 320, 5, 320, 5171, 8, 320, 10, 320, 12, 320, 5174, 9, - 320, 1, 321, 1, 321, 1, 321, 1, 321, 5, 321, 5180, 8, 321, 10, 321, 12, - 321, 5183, 9, 321, 1, 321, 1, 321, 1, 321, 3, 321, 5188, 8, 321, 1, 322, - 1, 322, 1, 322, 5, 322, 5193, 8, 322, 10, 322, 12, 322, 5196, 9, 322, 1, - 323, 1, 323, 1, 323, 5, 323, 5201, 8, 323, 10, 323, 12, 323, 5204, 9, 323, - 1, 324, 1, 324, 1, 324, 3, 324, 5209, 8, 324, 1, 325, 1, 325, 1, 325, 1, - 325, 1, 325, 3, 325, 5216, 8, 325, 1, 326, 1, 326, 1, 326, 1, 326, 5, 326, - 5222, 8, 326, 10, 326, 12, 326, 5225, 9, 326, 3, 326, 5227, 8, 326, 1, - 326, 1, 326, 1, 327, 1, 327, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, - 329, 1, 329, 1, 329, 1, 329, 3, 329, 5242, 8, 329, 1, 330, 1, 330, 1, 331, - 1, 331, 1, 331, 5, 331, 5249, 8, 331, 10, 331, 12, 331, 5252, 9, 331, 1, - 332, 1, 332, 1, 332, 1, 332, 3, 332, 5258, 8, 332, 1, 333, 1, 333, 1, 333, - 3, 333, 5263, 8, 333, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 0, 0, 336, - 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, - 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, - 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, - 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, - 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, - 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, - 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, - 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, - 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, - 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, - 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, - 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 0, 46, 2, 0, - 22, 22, 414, 414, 1, 0, 33, 34, 2, 0, 30, 30, 33, 33, 2, 0, 434, 435, 446, - 446, 2, 0, 92, 92, 446, 446, 2, 0, 390, 390, 418, 418, 1, 0, 93, 94, 2, - 0, 12, 12, 43, 43, 2, 0, 290, 290, 409, 409, 2, 0, 39, 39, 51, 51, 2, 0, - 14, 16, 53, 54, 2, 0, 457, 457, 463, 463, 3, 0, 68, 68, 133, 136, 297, - 297, 2, 0, 99, 99, 326, 329, 2, 0, 478, 478, 482, 482, 1, 0, 481, 482, - 1, 0, 280, 281, 6, 0, 280, 282, 448, 453, 457, 457, 461, 465, 468, 469, - 477, 481, 4, 0, 126, 126, 282, 282, 291, 292, 482, 483, 10, 0, 39, 39, + 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, + 181, 1, 181, 3, 181, 3206, 8, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, + 1, 181, 3, 181, 3214, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 3220, + 8, 182, 10, 182, 12, 182, 3223, 9, 182, 1, 182, 1, 182, 1, 183, 1, 183, + 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, + 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 3242, 8, 183, 1, 184, 1, 184, 5, + 184, 3246, 8, 184, 10, 184, 12, 184, 3249, 9, 184, 1, 185, 1, 185, 1, 185, + 1, 185, 1, 185, 3, 185, 3256, 8, 185, 1, 186, 1, 186, 1, 186, 3, 186, 3261, + 8, 186, 1, 186, 3, 186, 3264, 8, 186, 1, 187, 1, 187, 1, 188, 1, 188, 1, + 188, 1, 188, 5, 188, 3272, 8, 188, 10, 188, 12, 188, 3275, 9, 188, 1, 188, + 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 3354, 8, 189, 1, 190, 1, 190, 1, + 191, 1, 191, 1, 191, 1, 191, 5, 191, 3362, 8, 191, 10, 191, 12, 191, 3365, + 9, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 3, 192, 3372, 8, 192, 1, + 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 5, 192, 3380, 8, 192, 10, + 192, 12, 192, 3383, 9, 192, 1, 192, 3, 192, 3386, 8, 192, 3, 192, 3388, + 8, 192, 1, 192, 1, 192, 1, 192, 1, 192, 5, 192, 3394, 8, 192, 10, 192, + 12, 192, 3397, 9, 192, 3, 192, 3399, 8, 192, 1, 192, 1, 192, 1, 192, 3, + 192, 3404, 8, 192, 1, 192, 1, 192, 1, 192, 3, 192, 3409, 8, 192, 1, 192, + 1, 192, 1, 192, 1, 192, 3, 192, 3415, 8, 192, 1, 193, 1, 193, 3, 193, 3419, + 8, 193, 1, 193, 1, 193, 3, 193, 3423, 8, 193, 1, 193, 1, 193, 1, 193, 1, + 193, 3, 193, 3429, 8, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3435, + 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3440, 8, 193, 1, 193, 1, 193, 1, + 193, 3, 193, 3445, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3450, 8, 193, + 1, 193, 1, 193, 1, 193, 3, 193, 3455, 8, 193, 1, 194, 1, 194, 1, 194, 1, + 194, 5, 194, 3461, 8, 194, 10, 194, 12, 194, 3464, 9, 194, 1, 194, 1, 194, + 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 3474, 8, 195, 1, + 196, 1, 196, 1, 196, 3, 196, 3479, 8, 196, 1, 196, 1, 196, 1, 196, 1, 196, + 3, 196, 3485, 8, 196, 5, 196, 3487, 8, 196, 10, 196, 12, 196, 3490, 9, + 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 3498, 8, 197, + 3, 197, 3500, 8, 197, 3, 197, 3502, 8, 197, 1, 198, 1, 198, 1, 198, 1, + 198, 5, 198, 3508, 8, 198, 10, 198, 12, 198, 3511, 9, 198, 1, 198, 1, 198, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, + 1, 201, 1, 202, 1, 202, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, + 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, + 1, 204, 1, 204, 5, 204, 3544, 8, 204, 10, 204, 12, 204, 3547, 9, 204, 3, + 204, 3549, 8, 204, 1, 204, 3, 204, 3552, 8, 204, 1, 205, 1, 205, 1, 205, + 1, 205, 5, 205, 3558, 8, 205, 10, 205, 12, 205, 3561, 9, 205, 1, 205, 1, + 205, 1, 205, 1, 205, 3, 205, 3567, 8, 205, 1, 206, 1, 206, 1, 206, 1, 206, + 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 3578, 8, 206, 1, 207, 1, + 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 3, 208, 3587, 8, 208, 1, 208, + 1, 208, 5, 208, 3591, 8, 208, 10, 208, 12, 208, 3594, 9, 208, 1, 208, 1, + 208, 1, 209, 4, 209, 3599, 8, 209, 11, 209, 12, 209, 3600, 1, 210, 1, 210, + 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 3610, 8, 211, 1, 212, 1, + 212, 1, 212, 1, 212, 4, 212, 3616, 8, 212, 11, 212, 12, 212, 3617, 1, 212, + 1, 212, 5, 212, 3622, 8, 212, 10, 212, 12, 212, 3625, 9, 212, 1, 212, 3, + 212, 3628, 8, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 3, 213, 3637, 8, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 3, 213, 3649, 8, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 3, 213, 3655, 8, 213, 3, 213, 3657, 8, 213, 1, 214, 1, 214, 1, + 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, + 214, 3670, 8, 214, 5, 214, 3672, 8, 214, 10, 214, 12, 214, 3675, 9, 214, + 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 5, 214, 3684, 8, + 214, 10, 214, 12, 214, 3687, 9, 214, 1, 214, 1, 214, 3, 214, 3691, 8, 214, + 3, 214, 3693, 8, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 3708, 8, 216, + 1, 217, 4, 217, 3711, 8, 217, 11, 217, 12, 217, 3712, 1, 218, 1, 218, 1, + 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 5, 219, 3724, 8, 219, + 10, 219, 12, 219, 3727, 9, 219, 1, 219, 1, 219, 1, 220, 4, 220, 3732, 8, + 220, 11, 220, 12, 220, 3733, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 221, 1, 221, 3, 221, 3745, 8, 221, 1, 222, 1, 222, 1, 222, + 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 3755, 8, 222, 1, 223, 1, + 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 3764, 8, 223, 1, 224, + 1, 224, 1, 225, 4, 225, 3769, 8, 225, 11, 225, 12, 225, 3770, 1, 226, 1, + 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 3781, 8, 226, + 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, + 3, 228, 3792, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, + 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 5, + 230, 3809, 8, 230, 10, 230, 12, 230, 3812, 9, 230, 1, 230, 1, 230, 3, 230, + 3816, 8, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 5, + 231, 3825, 8, 231, 10, 231, 12, 231, 3828, 9, 231, 1, 231, 1, 231, 3, 231, + 3832, 8, 231, 1, 231, 1, 231, 5, 231, 3836, 8, 231, 10, 231, 12, 231, 3839, + 9, 231, 1, 231, 3, 231, 3842, 8, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, + 232, 1, 232, 3, 232, 3850, 8, 232, 1, 232, 3, 232, 3853, 8, 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, 5, 235, 3867, 8, 235, 10, 235, 12, 235, 3870, 9, 235, 1, + 236, 1, 236, 1, 236, 1, 236, 1, 236, 3, 236, 3877, 8, 236, 1, 236, 3, 236, + 3880, 8, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 3, 237, 3887, 8, + 237, 1, 237, 1, 237, 1, 237, 1, 237, 5, 237, 3893, 8, 237, 10, 237, 12, + 237, 3896, 9, 237, 1, 237, 1, 237, 3, 237, 3900, 8, 237, 1, 237, 3, 237, + 3903, 8, 237, 1, 237, 3, 237, 3906, 8, 237, 1, 238, 1, 238, 1, 238, 1, + 238, 1, 238, 1, 238, 5, 238, 3914, 8, 238, 10, 238, 12, 238, 3917, 9, 238, + 3, 238, 3919, 8, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 3, 239, 3926, + 8, 239, 1, 239, 3, 239, 3929, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 5, + 240, 3935, 8, 240, 10, 240, 12, 240, 3938, 9, 240, 1, 240, 1, 240, 1, 241, + 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, + 1, 241, 5, 241, 3953, 8, 241, 10, 241, 12, 241, 3956, 9, 241, 1, 241, 1, + 241, 1, 241, 3, 241, 3961, 8, 241, 1, 241, 3, 241, 3964, 8, 241, 1, 242, + 1, 242, 1, 242, 3, 242, 3969, 8, 242, 1, 242, 5, 242, 3972, 8, 242, 10, + 242, 12, 242, 3975, 9, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 5, + 243, 3982, 8, 243, 10, 243, 12, 243, 3985, 9, 243, 1, 243, 1, 243, 1, 244, + 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, + 1, 245, 1, 245, 5, 245, 4001, 8, 245, 10, 245, 12, 245, 4004, 9, 245, 1, + 245, 1, 245, 1, 245, 4, 245, 4009, 8, 245, 11, 245, 12, 245, 4010, 1, 245, + 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 5, 246, 4021, 8, + 246, 10, 246, 12, 246, 4024, 9, 246, 1, 246, 1, 246, 1, 246, 1, 246, 3, + 246, 4030, 8, 246, 1, 246, 1, 246, 3, 246, 4034, 8, 246, 1, 246, 1, 246, + 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, + 1, 248, 3, 248, 4048, 8, 248, 1, 248, 1, 248, 3, 248, 4052, 8, 248, 1, + 248, 1, 248, 3, 248, 4056, 8, 248, 1, 248, 1, 248, 1, 248, 3, 248, 4061, + 8, 248, 1, 248, 1, 248, 1, 248, 3, 248, 4066, 8, 248, 1, 248, 1, 248, 1, + 248, 3, 248, 4071, 8, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 3, 248, + 4078, 8, 248, 1, 248, 3, 248, 4081, 8, 248, 1, 249, 5, 249, 4084, 8, 249, + 10, 249, 12, 249, 4087, 9, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 4116, 8, 250, 1, 251, 1, 251, 1, + 251, 1, 251, 1, 251, 1, 251, 3, 251, 4124, 8, 251, 1, 251, 1, 251, 1, 251, + 3, 251, 4129, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4134, 8, 251, 1, + 251, 1, 251, 3, 251, 4138, 8, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4143, + 8, 251, 1, 251, 1, 251, 3, 251, 4147, 8, 251, 1, 251, 1, 251, 4, 251, 4151, + 8, 251, 11, 251, 12, 251, 4152, 3, 251, 4155, 8, 251, 1, 251, 1, 251, 1, + 251, 4, 251, 4160, 8, 251, 11, 251, 12, 251, 4161, 3, 251, 4164, 8, 251, + 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4173, 8, + 251, 1, 251, 1, 251, 1, 251, 3, 251, 4178, 8, 251, 1, 251, 1, 251, 1, 251, + 3, 251, 4183, 8, 251, 1, 251, 1, 251, 3, 251, 4187, 8, 251, 1, 251, 1, + 251, 1, 251, 3, 251, 4192, 8, 251, 1, 251, 1, 251, 3, 251, 4196, 8, 251, + 1, 251, 1, 251, 4, 251, 4200, 8, 251, 11, 251, 12, 251, 4201, 3, 251, 4204, + 8, 251, 1, 251, 1, 251, 1, 251, 4, 251, 4209, 8, 251, 11, 251, 12, 251, + 4210, 3, 251, 4213, 8, 251, 3, 251, 4215, 8, 251, 1, 252, 1, 252, 1, 252, + 3, 252, 4220, 8, 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4226, 8, + 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4232, 8, 252, 1, 252, 1, 252, + 1, 252, 1, 252, 3, 252, 4238, 8, 252, 1, 252, 1, 252, 3, 252, 4242, 8, + 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4248, 8, 252, 3, 252, 4250, + 8, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, + 1, 254, 1, 254, 3, 254, 4262, 8, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, + 254, 5, 254, 4269, 8, 254, 10, 254, 12, 254, 4272, 9, 254, 1, 254, 1, 254, + 3, 254, 4276, 8, 254, 1, 254, 1, 254, 4, 254, 4280, 8, 254, 11, 254, 12, + 254, 4281, 3, 254, 4284, 8, 254, 1, 254, 1, 254, 1, 254, 4, 254, 4289, + 8, 254, 11, 254, 12, 254, 4290, 3, 254, 4293, 8, 254, 1, 255, 1, 255, 1, + 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 3, 256, 4304, 8, 256, + 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 5, 256, 4311, 8, 256, 10, 256, + 12, 256, 4314, 9, 256, 1, 256, 1, 256, 3, 256, 4318, 8, 256, 1, 257, 1, + 257, 3, 257, 4322, 8, 257, 1, 257, 1, 257, 3, 257, 4326, 8, 257, 1, 257, + 1, 257, 4, 257, 4330, 8, 257, 11, 257, 12, 257, 4331, 3, 257, 4334, 8, + 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, + 259, 1, 259, 3, 259, 4346, 8, 259, 1, 259, 4, 259, 4349, 8, 259, 11, 259, + 12, 259, 4350, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, + 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 4364, 8, 261, 1, 262, 1, 262, 1, + 262, 1, 262, 3, 262, 4370, 8, 262, 1, 262, 1, 262, 3, 262, 4374, 8, 262, + 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 3, 263, 4381, 8, 263, 1, 263, 1, + 263, 1, 263, 4, 263, 4386, 8, 263, 11, 263, 12, 263, 4387, 3, 263, 4390, + 8, 263, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 5, 265, + 4399, 8, 265, 10, 265, 12, 265, 4402, 9, 265, 1, 265, 1, 265, 1, 265, 1, + 265, 1, 265, 1, 265, 1, 265, 3, 265, 4411, 8, 265, 1, 265, 1, 265, 1, 265, + 1, 265, 1, 265, 5, 265, 4418, 8, 265, 10, 265, 12, 265, 4421, 9, 265, 3, + 265, 4423, 8, 265, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, + 1, 268, 1, 268, 1, 268, 3, 268, 4435, 8, 268, 1, 269, 1, 269, 1, 269, 1, + 269, 3, 269, 4441, 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, + 1, 270, 3, 270, 4450, 8, 270, 3, 270, 4452, 8, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 3, 270, 4459, 8, 270, 3, 270, 4461, 8, 270, 1, 270, + 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4468, 8, 270, 3, 270, 4470, 8, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4477, 8, 270, 3, 270, + 4479, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4486, 8, + 270, 3, 270, 4488, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, + 4495, 8, 270, 3, 270, 4497, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 3, 270, 4504, 8, 270, 3, 270, 4506, 8, 270, 1, 270, 1, 270, 1, 270, + 1, 270, 1, 270, 3, 270, 4513, 8, 270, 3, 270, 4515, 8, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 3, 270, 4522, 8, 270, 3, 270, 4524, 8, 270, + 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4531, 8, 270, 3, 270, 4533, + 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4540, 8, 270, 3, + 270, 4542, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, + 4550, 8, 270, 3, 270, 4552, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 3, 270, 4580, 8, 270, 1, 270, 1, 270, 1, 270, + 1, 270, 1, 270, 3, 270, 4587, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 3, 270, 4603, 8, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4608, 8, 270, + 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, + 3, 270, 4619, 8, 270, 3, 270, 4621, 8, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 3, 270, 4654, 8, 270, 3, 270, 4656, 8, 270, 1, 270, 1, 270, 1, 270, + 1, 270, 1, 270, 1, 270, 3, 270, 4664, 8, 270, 3, 270, 4666, 8, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4674, 8, 270, 3, 270, + 4676, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4684, + 8, 270, 3, 270, 4686, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 3, 270, 4695, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, + 1, 270, 1, 270, 1, 270, 3, 270, 4705, 8, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 3, 270, 4711, 8, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4716, 8, 270, + 3, 270, 4718, 8, 270, 1, 270, 3, 270, 4721, 8, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 4730, 8, 270, 3, 270, 4732, + 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, + 4741, 8, 270, 3, 270, 4743, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 3, 270, 4751, 8, 270, 3, 270, 4753, 8, 270, 1, 270, 1, 270, + 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, + 4765, 8, 270, 3, 270, 4767, 8, 270, 3, 270, 4769, 8, 270, 1, 271, 1, 271, + 1, 271, 1, 271, 5, 271, 4775, 8, 271, 10, 271, 12, 271, 4778, 9, 271, 1, + 271, 1, 271, 1, 271, 3, 271, 4783, 8, 271, 3, 271, 4785, 8, 271, 1, 271, + 1, 271, 1, 271, 3, 271, 4790, 8, 271, 3, 271, 4792, 8, 271, 1, 272, 1, + 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 4802, 8, 273, + 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, + 4812, 8, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 4853, 8, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, + 4883, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, + 276, 4892, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 3, 276, 4928, 8, 276, 1, 277, 1, 277, 3, 277, 4932, 8, 277, 1, 277, 1, + 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 4940, 8, 277, 1, 277, 3, 277, + 4943, 8, 277, 1, 277, 5, 277, 4946, 8, 277, 10, 277, 12, 277, 4949, 9, + 277, 1, 277, 1, 277, 3, 277, 4953, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, + 3, 277, 4959, 8, 277, 3, 277, 4961, 8, 277, 1, 277, 1, 277, 3, 277, 4965, + 8, 277, 1, 277, 1, 277, 3, 277, 4969, 8, 277, 1, 277, 1, 277, 3, 277, 4973, + 8, 277, 1, 278, 3, 278, 4976, 8, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, + 278, 3, 278, 4983, 8, 278, 1, 278, 3, 278, 4986, 8, 278, 1, 278, 1, 278, + 3, 278, 4990, 8, 278, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 3, 280, 4997, + 8, 280, 1, 280, 5, 280, 5000, 8, 280, 10, 280, 12, 280, 5003, 9, 280, 1, + 281, 1, 281, 3, 281, 5007, 8, 281, 1, 281, 3, 281, 5010, 8, 281, 1, 281, + 3, 281, 5013, 8, 281, 1, 281, 3, 281, 5016, 8, 281, 1, 281, 3, 281, 5019, + 8, 281, 1, 281, 3, 281, 5022, 8, 281, 1, 281, 1, 281, 3, 281, 5026, 8, + 281, 1, 281, 3, 281, 5029, 8, 281, 1, 281, 3, 281, 5032, 8, 281, 1, 281, + 1, 281, 3, 281, 5036, 8, 281, 1, 281, 3, 281, 5039, 8, 281, 3, 281, 5041, + 8, 281, 1, 282, 1, 282, 3, 282, 5045, 8, 282, 1, 282, 1, 282, 1, 283, 1, + 283, 1, 283, 1, 283, 5, 283, 5053, 8, 283, 10, 283, 12, 283, 5056, 9, 283, + 3, 283, 5058, 8, 283, 1, 284, 1, 284, 1, 284, 3, 284, 5063, 8, 284, 1, + 284, 1, 284, 1, 284, 3, 284, 5068, 8, 284, 3, 284, 5070, 8, 284, 1, 285, + 1, 285, 3, 285, 5074, 8, 285, 1, 286, 1, 286, 1, 286, 5, 286, 5079, 8, + 286, 10, 286, 12, 286, 5082, 9, 286, 1, 287, 1, 287, 3, 287, 5086, 8, 287, + 1, 287, 3, 287, 5089, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 5095, + 8, 287, 1, 287, 3, 287, 5098, 8, 287, 3, 287, 5100, 8, 287, 1, 288, 3, + 288, 5103, 8, 288, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 5109, 8, 288, + 1, 288, 3, 288, 5112, 8, 288, 1, 288, 1, 288, 1, 288, 3, 288, 5117, 8, + 288, 1, 288, 3, 288, 5120, 8, 288, 3, 288, 5122, 8, 288, 1, 289, 1, 289, + 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, + 5134, 8, 289, 1, 290, 1, 290, 3, 290, 5138, 8, 290, 1, 290, 1, 290, 3, + 290, 5142, 8, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5147, 8, 290, 1, 290, + 3, 290, 5150, 8, 290, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, + 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 5, + 295, 5167, 8, 295, 10, 295, 12, 295, 5170, 9, 295, 1, 296, 1, 296, 3, 296, + 5174, 8, 296, 1, 297, 1, 297, 1, 297, 5, 297, 5179, 8, 297, 10, 297, 12, + 297, 5182, 9, 297, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 5188, 8, 298, + 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 5194, 8, 298, 3, 298, 5196, 8, + 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, + 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, 5214, + 8, 299, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, + 1, 301, 3, 301, 5225, 8, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, + 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 5240, + 8, 301, 3, 301, 5242, 8, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, + 303, 3, 303, 5250, 8, 303, 1, 303, 3, 303, 5253, 8, 303, 1, 303, 3, 303, + 5256, 8, 303, 1, 303, 3, 303, 5259, 8, 303, 1, 303, 3, 303, 5262, 8, 303, + 1, 304, 1, 304, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, + 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 3, 308, 5278, 8, 308, 1, 308, 1, + 308, 3, 308, 5282, 8, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5287, 8, 308, + 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 5295, 8, 309, 1, + 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 5303, 8, 311, 1, 312, + 1, 312, 1, 312, 5, 312, 5308, 8, 312, 10, 312, 12, 312, 5311, 9, 312, 1, + 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 316, 1, + 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 5, 316, 5351, 8, 316, 10, 316, 12, 316, 5354, 9, 316, 1, 316, + 1, 316, 3, 316, 5358, 8, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 5, + 316, 5365, 8, 316, 10, 316, 12, 316, 5368, 9, 316, 1, 316, 1, 316, 3, 316, + 5372, 8, 316, 1, 316, 3, 316, 5375, 8, 316, 1, 316, 1, 316, 1, 316, 3, + 316, 5380, 8, 316, 1, 317, 4, 317, 5383, 8, 317, 11, 317, 12, 317, 5384, + 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, + 1, 318, 1, 318, 1, 318, 5, 318, 5399, 8, 318, 10, 318, 12, 318, 5402, 9, + 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 5, 318, 5410, 8, 318, + 10, 318, 12, 318, 5413, 9, 318, 1, 318, 1, 318, 3, 318, 5417, 8, 318, 1, + 318, 1, 318, 3, 318, 5421, 8, 318, 1, 318, 1, 318, 3, 318, 5425, 8, 318, + 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, + 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 5441, 8, 320, 1, 321, 1, + 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, + 323, 1, 323, 1, 324, 1, 324, 1, 324, 5, 324, 5458, 8, 324, 10, 324, 12, + 324, 5461, 9, 324, 1, 325, 1, 325, 1, 325, 5, 325, 5466, 8, 325, 10, 325, + 12, 325, 5469, 9, 325, 1, 326, 3, 326, 5472, 8, 326, 1, 326, 1, 326, 1, + 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, + 327, 3, 327, 5486, 8, 327, 1, 327, 1, 327, 1, 327, 3, 327, 5491, 8, 327, + 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 5499, 8, 327, 1, + 327, 1, 327, 1, 327, 1, 327, 3, 327, 5505, 8, 327, 1, 328, 1, 328, 1, 329, + 1, 329, 1, 329, 5, 329, 5512, 8, 329, 10, 329, 12, 329, 5515, 9, 329, 1, + 330, 1, 330, 1, 330, 5, 330, 5520, 8, 330, 10, 330, 12, 330, 5523, 9, 330, + 1, 331, 3, 331, 5526, 8, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, + 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, + 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 3, 332, 5550, + 8, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 4, 333, 5558, 8, + 333, 11, 333, 12, 333, 5559, 1, 333, 1, 333, 3, 333, 5564, 8, 333, 1, 333, + 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, + 1, 335, 1, 336, 1, 336, 1, 336, 3, 336, 5580, 8, 336, 1, 336, 1, 336, 3, + 336, 5584, 8, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 3, 337, 5591, + 8, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 5, 339, + 5600, 8, 339, 10, 339, 12, 339, 5603, 9, 339, 1, 340, 1, 340, 1, 340, 1, + 340, 5, 340, 5609, 8, 340, 10, 340, 12, 340, 5612, 9, 340, 1, 340, 1, 340, + 1, 340, 3, 340, 5617, 8, 340, 1, 341, 1, 341, 1, 341, 5, 341, 5622, 8, + 341, 10, 341, 12, 341, 5625, 9, 341, 1, 342, 1, 342, 1, 342, 5, 342, 5630, + 8, 342, 10, 342, 12, 342, 5633, 9, 342, 1, 343, 1, 343, 1, 343, 3, 343, + 5638, 8, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 3, 344, 5645, 8, + 344, 1, 345, 1, 345, 1, 345, 1, 345, 5, 345, 5651, 8, 345, 10, 345, 12, + 345, 5654, 9, 345, 3, 345, 5656, 8, 345, 1, 345, 1, 345, 1, 346, 1, 346, + 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 3, 348, 5671, 8, 348, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 5, 350, 5678, + 8, 350, 10, 350, 12, 350, 5681, 9, 350, 1, 351, 1, 351, 1, 351, 1, 351, + 3, 351, 5687, 8, 351, 1, 352, 1, 352, 1, 352, 3, 352, 5692, 8, 352, 1, + 353, 1, 353, 1, 354, 1, 354, 1, 354, 0, 0, 355, 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, 348, 350, 352, 354, 356, + 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, + 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, + 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, + 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, + 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, + 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, + 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, + 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, + 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, + 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, + 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, + 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 0, 48, 2, 0, 22, + 22, 415, 415, 1, 0, 33, 34, 2, 0, 30, 30, 33, 33, 2, 0, 435, 436, 467, + 467, 2, 0, 92, 92, 467, 467, 2, 0, 391, 391, 419, 419, 1, 0, 93, 94, 2, + 0, 12, 12, 43, 43, 2, 0, 290, 290, 410, 410, 2, 0, 39, 39, 51, 51, 2, 0, + 14, 16, 53, 54, 2, 0, 478, 478, 484, 484, 3, 0, 68, 68, 133, 136, 297, + 297, 2, 0, 99, 99, 327, 330, 2, 0, 499, 499, 503, 503, 1, 0, 502, 503, + 1, 0, 280, 281, 6, 0, 280, 282, 469, 474, 478, 478, 482, 486, 489, 490, + 498, 502, 4, 0, 126, 126, 282, 282, 291, 292, 503, 504, 10, 0, 39, 39, 146, 155, 158, 160, 162, 163, 165, 165, 167, 174, 178, 183, 192, 193, 222, - 226, 246, 246, 3, 0, 126, 126, 138, 138, 482, 482, 3, 0, 250, 256, 390, - 390, 482, 482, 4, 0, 133, 134, 241, 245, 290, 290, 482, 482, 2, 0, 213, - 213, 480, 480, 1, 0, 406, 408, 1, 0, 478, 479, 4, 0, 193, 193, 317, 317, - 319, 319, 344, 344, 2, 0, 333, 333, 426, 426, 2, 0, 372, 372, 482, 482, - 7, 0, 146, 152, 158, 160, 163, 163, 167, 174, 192, 193, 222, 226, 482, - 482, 2, 0, 286, 286, 451, 451, 1, 0, 83, 84, 8, 0, 141, 143, 185, 185, - 190, 190, 220, 220, 308, 308, 367, 368, 370, 373, 482, 482, 2, 0, 322, - 322, 390, 391, 1, 0, 482, 483, 2, 1, 457, 457, 461, 461, 1, 0, 448, 453, - 1, 0, 454, 455, 2, 0, 456, 460, 470, 470, 1, 0, 257, 262, 1, 0, 271, 275, - 7, 0, 121, 121, 126, 126, 138, 138, 183, 183, 271, 277, 291, 292, 482, - 483, 1, 0, 291, 292, 6, 0, 48, 48, 186, 187, 215, 215, 296, 296, 393, 393, - 482, 482, 36, 0, 41, 43, 48, 48, 50, 51, 53, 53, 68, 68, 114, 114, 122, - 122, 133, 134, 136, 136, 162, 162, 166, 166, 186, 186, 189, 191, 194, 194, - 203, 204, 211, 212, 214, 215, 218, 218, 227, 227, 242, 242, 271, 275, 297, - 297, 299, 299, 324, 325, 340, 341, 361, 361, 364, 364, 384, 384, 390, 390, - 392, 392, 404, 409, 417, 417, 430, 430, 434, 435, 440, 442, 445, 446, 55, - 0, 8, 9, 17, 21, 23, 30, 33, 35, 38, 43, 47, 48, 50, 51, 53, 53, 55, 58, - 64, 66, 68, 75, 80, 89, 92, 92, 95, 100, 102, 105, 109, 109, 111, 116, - 118, 118, 122, 122, 130, 130, 133, 134, 136, 137, 139, 144, 146, 151, 154, - 164, 166, 170, 172, 173, 177, 177, 185, 186, 189, 194, 203, 212, 214, 215, - 217, 218, 222, 227, 240, 243, 246, 246, 257, 265, 271, 275, 280, 286, 289, - 297, 299, 302, 305, 320, 322, 325, 330, 356, 358, 374, 376, 388, 390, 390, - 392, 392, 394, 395, 397, 415, 417, 417, 419, 419, 422, 422, 424, 447, 459, - 460, 5950, 0, 675, 1, 0, 0, 0, 2, 681, 1, 0, 0, 0, 4, 701, 1, 0, 0, 0, - 6, 703, 1, 0, 0, 0, 8, 735, 1, 0, 0, 0, 10, 864, 1, 0, 0, 0, 12, 878, 1, - 0, 0, 0, 14, 895, 1, 0, 0, 0, 16, 913, 1, 0, 0, 0, 18, 936, 1, 0, 0, 0, - 20, 945, 1, 0, 0, 0, 22, 961, 1, 0, 0, 0, 24, 963, 1, 0, 0, 0, 26, 973, - 1, 0, 0, 0, 28, 1003, 1, 0, 0, 0, 30, 1030, 1, 0, 0, 0, 32, 1085, 1, 0, - 0, 0, 34, 1098, 1, 0, 0, 0, 36, 1147, 1, 0, 0, 0, 38, 1166, 1, 0, 0, 0, - 40, 1168, 1, 0, 0, 0, 42, 1176, 1, 0, 0, 0, 44, 1181, 1, 0, 0, 0, 46, 1215, - 1, 0, 0, 0, 48, 1217, 1, 0, 0, 0, 50, 1222, 1, 0, 0, 0, 52, 1233, 1, 0, - 0, 0, 54, 1238, 1, 0, 0, 0, 56, 1246, 1, 0, 0, 0, 58, 1254, 1, 0, 0, 0, - 60, 1262, 1, 0, 0, 0, 62, 1270, 1, 0, 0, 0, 64, 1279, 1, 0, 0, 0, 66, 1299, - 1, 0, 0, 0, 68, 1301, 1, 0, 0, 0, 70, 1318, 1, 0, 0, 0, 72, 1323, 1, 0, - 0, 0, 74, 1329, 1, 0, 0, 0, 76, 1337, 1, 0, 0, 0, 78, 1373, 1, 0, 0, 0, - 80, 1421, 1, 0, 0, 0, 82, 1427, 1, 0, 0, 0, 84, 1438, 1, 0, 0, 0, 86, 1440, - 1, 0, 0, 0, 88, 1454, 1, 0, 0, 0, 90, 1456, 1, 0, 0, 0, 92, 1465, 1, 0, - 0, 0, 94, 1485, 1, 0, 0, 0, 96, 1513, 1, 0, 0, 0, 98, 1551, 1, 0, 0, 0, - 100, 1553, 1, 0, 0, 0, 102, 1580, 1, 0, 0, 0, 104, 1583, 1, 0, 0, 0, 106, - 1589, 1, 0, 0, 0, 108, 1597, 1, 0, 0, 0, 110, 1604, 1, 0, 0, 0, 112, 1606, - 1, 0, 0, 0, 114, 1616, 1, 0, 0, 0, 116, 1630, 1, 0, 0, 0, 118, 1632, 1, - 0, 0, 0, 120, 1690, 1, 0, 0, 0, 122, 1704, 1, 0, 0, 0, 124, 1724, 1, 0, - 0, 0, 126, 1739, 1, 0, 0, 0, 128, 1741, 1, 0, 0, 0, 130, 1747, 1, 0, 0, - 0, 132, 1755, 1, 0, 0, 0, 134, 1757, 1, 0, 0, 0, 136, 1765, 1, 0, 0, 0, - 138, 1774, 1, 0, 0, 0, 140, 1798, 1, 0, 0, 0, 142, 1801, 1, 0, 0, 0, 144, - 1805, 1, 0, 0, 0, 146, 1808, 1, 0, 0, 0, 148, 1842, 1, 0, 0, 0, 150, 1857, - 1, 0, 0, 0, 152, 1859, 1, 0, 0, 0, 154, 1867, 1, 0, 0, 0, 156, 1875, 1, - 0, 0, 0, 158, 1897, 1, 0, 0, 0, 160, 1916, 1, 0, 0, 0, 162, 1924, 1, 0, - 0, 0, 164, 1930, 1, 0, 0, 0, 166, 1933, 1, 0, 0, 0, 168, 1939, 1, 0, 0, - 0, 170, 1949, 1, 0, 0, 0, 172, 1957, 1, 0, 0, 0, 174, 1959, 1, 0, 0, 0, - 176, 1966, 1, 0, 0, 0, 178, 1974, 1, 0, 0, 0, 180, 1979, 1, 0, 0, 0, 182, - 2302, 1, 0, 0, 0, 184, 2304, 1, 0, 0, 0, 186, 2311, 1, 0, 0, 0, 188, 2321, - 1, 0, 0, 0, 190, 2335, 1, 0, 0, 0, 192, 2344, 1, 0, 0, 0, 194, 2354, 1, - 0, 0, 0, 196, 2366, 1, 0, 0, 0, 198, 2371, 1, 0, 0, 0, 200, 2376, 1, 0, - 0, 0, 202, 2416, 1, 0, 0, 0, 204, 2438, 1, 0, 0, 0, 206, 2440, 1, 0, 0, - 0, 208, 2461, 1, 0, 0, 0, 210, 2473, 1, 0, 0, 0, 212, 2483, 1, 0, 0, 0, - 214, 2485, 1, 0, 0, 0, 216, 2487, 1, 0, 0, 0, 218, 2491, 1, 0, 0, 0, 220, - 2494, 1, 0, 0, 0, 222, 2506, 1, 0, 0, 0, 224, 2522, 1, 0, 0, 0, 226, 2524, - 1, 0, 0, 0, 228, 2530, 1, 0, 0, 0, 230, 2532, 1, 0, 0, 0, 232, 2536, 1, - 0, 0, 0, 234, 2551, 1, 0, 0, 0, 236, 2567, 1, 0, 0, 0, 238, 2601, 1, 0, - 0, 0, 240, 2615, 1, 0, 0, 0, 242, 2625, 1, 0, 0, 0, 244, 2630, 1, 0, 0, - 0, 246, 2648, 1, 0, 0, 0, 248, 2666, 1, 0, 0, 0, 250, 2668, 1, 0, 0, 0, - 252, 2671, 1, 0, 0, 0, 254, 2675, 1, 0, 0, 0, 256, 2689, 1, 0, 0, 0, 258, - 2692, 1, 0, 0, 0, 260, 2706, 1, 0, 0, 0, 262, 2734, 1, 0, 0, 0, 264, 2738, - 1, 0, 0, 0, 266, 2740, 1, 0, 0, 0, 268, 2742, 1, 0, 0, 0, 270, 2747, 1, - 0, 0, 0, 272, 2769, 1, 0, 0, 0, 274, 2771, 1, 0, 0, 0, 276, 2788, 1, 0, - 0, 0, 278, 2790, 1, 0, 0, 0, 280, 2853, 1, 0, 0, 0, 282, 2855, 1, 0, 0, - 0, 284, 2863, 1, 0, 0, 0, 286, 2867, 1, 0, 0, 0, 288, 2895, 1, 0, 0, 0, - 290, 2897, 1, 0, 0, 0, 292, 2903, 1, 0, 0, 0, 294, 2908, 1, 0, 0, 0, 296, - 2913, 1, 0, 0, 0, 298, 2921, 1, 0, 0, 0, 300, 2929, 1, 0, 0, 0, 302, 2931, - 1, 0, 0, 0, 304, 2939, 1, 0, 0, 0, 306, 2943, 1, 0, 0, 0, 308, 2950, 1, - 0, 0, 0, 310, 2963, 1, 0, 0, 0, 312, 2967, 1, 0, 0, 0, 314, 2970, 1, 0, - 0, 0, 316, 2978, 1, 0, 0, 0, 318, 2982, 1, 0, 0, 0, 320, 2990, 1, 0, 0, - 0, 322, 2994, 1, 0, 0, 0, 324, 3002, 1, 0, 0, 0, 326, 3010, 1, 0, 0, 0, - 328, 3015, 1, 0, 0, 0, 330, 3019, 1, 0, 0, 0, 332, 3021, 1, 0, 0, 0, 334, - 3029, 1, 0, 0, 0, 336, 3040, 1, 0, 0, 0, 338, 3042, 1, 0, 0, 0, 340, 3054, - 1, 0, 0, 0, 342, 3056, 1, 0, 0, 0, 344, 3064, 1, 0, 0, 0, 346, 3076, 1, - 0, 0, 0, 348, 3078, 1, 0, 0, 0, 350, 3086, 1, 0, 0, 0, 352, 3088, 1, 0, - 0, 0, 354, 3102, 1, 0, 0, 0, 356, 3104, 1, 0, 0, 0, 358, 3142, 1, 0, 0, - 0, 360, 3144, 1, 0, 0, 0, 362, 3170, 1, 0, 0, 0, 364, 3176, 1, 0, 0, 0, - 366, 3179, 1, 0, 0, 0, 368, 3186, 1, 0, 0, 0, 370, 3194, 1, 0, 0, 0, 372, - 3196, 1, 0, 0, 0, 374, 3282, 1, 0, 0, 0, 376, 3284, 1, 0, 0, 0, 378, 3286, - 1, 0, 0, 0, 380, 3343, 1, 0, 0, 0, 382, 3383, 1, 0, 0, 0, 384, 3385, 1, - 0, 0, 0, 386, 3402, 1, 0, 0, 0, 388, 3407, 1, 0, 0, 0, 390, 3430, 1, 0, - 0, 0, 392, 3432, 1, 0, 0, 0, 394, 3443, 1, 0, 0, 0, 396, 3449, 1, 0, 0, - 0, 398, 3451, 1, 0, 0, 0, 400, 3453, 1, 0, 0, 0, 402, 3455, 1, 0, 0, 0, - 404, 3480, 1, 0, 0, 0, 406, 3495, 1, 0, 0, 0, 408, 3506, 1, 0, 0, 0, 410, - 3508, 1, 0, 0, 0, 412, 3512, 1, 0, 0, 0, 414, 3527, 1, 0, 0, 0, 416, 3531, - 1, 0, 0, 0, 418, 3534, 1, 0, 0, 0, 420, 3540, 1, 0, 0, 0, 422, 3585, 1, - 0, 0, 0, 424, 3587, 1, 0, 0, 0, 426, 3625, 1, 0, 0, 0, 428, 3629, 1, 0, - 0, 0, 430, 3639, 1, 0, 0, 0, 432, 3643, 1, 0, 0, 0, 434, 3646, 1, 0, 0, - 0, 436, 3660, 1, 0, 0, 0, 438, 3673, 1, 0, 0, 0, 440, 3683, 1, 0, 0, 0, - 442, 3685, 1, 0, 0, 0, 444, 3694, 1, 0, 0, 0, 446, 3697, 1, 0, 0, 0, 448, - 3709, 1, 0, 0, 0, 450, 3711, 1, 0, 0, 0, 452, 3715, 1, 0, 0, 0, 454, 3722, - 1, 0, 0, 0, 456, 3730, 1, 0, 0, 0, 458, 3746, 1, 0, 0, 0, 460, 3781, 1, - 0, 0, 0, 462, 3783, 1, 0, 0, 0, 464, 3787, 1, 0, 0, 0, 466, 3791, 1, 0, - 0, 0, 468, 3808, 1, 0, 0, 0, 470, 3810, 1, 0, 0, 0, 472, 3836, 1, 0, 0, - 0, 474, 3851, 1, 0, 0, 0, 476, 3859, 1, 0, 0, 0, 478, 3870, 1, 0, 0, 0, - 480, 3894, 1, 0, 0, 0, 482, 3905, 1, 0, 0, 0, 484, 3917, 1, 0, 0, 0, 486, - 3921, 1, 0, 0, 0, 488, 3943, 1, 0, 0, 0, 490, 3966, 1, 0, 0, 0, 492, 3998, - 1, 0, 0, 0, 494, 4000, 1, 0, 0, 0, 496, 4002, 1, 0, 0, 0, 498, 4010, 1, - 0, 0, 0, 500, 4016, 1, 0, 0, 0, 502, 4339, 1, 0, 0, 0, 504, 4362, 1, 0, - 0, 0, 506, 4364, 1, 0, 0, 0, 508, 4372, 1, 0, 0, 0, 510, 4374, 1, 0, 0, - 0, 512, 4382, 1, 0, 0, 0, 514, 4498, 1, 0, 0, 0, 516, 4500, 1, 0, 0, 0, - 518, 4546, 1, 0, 0, 0, 520, 4562, 1, 0, 0, 0, 522, 4564, 1, 0, 0, 0, 524, - 4611, 1, 0, 0, 0, 526, 4613, 1, 0, 0, 0, 528, 4628, 1, 0, 0, 0, 530, 4640, - 1, 0, 0, 0, 532, 4644, 1, 0, 0, 0, 534, 4646, 1, 0, 0, 0, 536, 4670, 1, - 0, 0, 0, 538, 4692, 1, 0, 0, 0, 540, 4704, 1, 0, 0, 0, 542, 4720, 1, 0, - 0, 0, 544, 4722, 1, 0, 0, 0, 546, 4725, 1, 0, 0, 0, 548, 4728, 1, 0, 0, - 0, 550, 4731, 1, 0, 0, 0, 552, 4734, 1, 0, 0, 0, 554, 4742, 1, 0, 0, 0, - 556, 4746, 1, 0, 0, 0, 558, 4766, 1, 0, 0, 0, 560, 4784, 1, 0, 0, 0, 562, - 4786, 1, 0, 0, 0, 564, 4812, 1, 0, 0, 0, 566, 4814, 1, 0, 0, 0, 568, 4832, - 1, 0, 0, 0, 570, 4834, 1, 0, 0, 0, 572, 4836, 1, 0, 0, 0, 574, 4838, 1, - 0, 0, 0, 576, 4842, 1, 0, 0, 0, 578, 4857, 1, 0, 0, 0, 580, 4865, 1, 0, - 0, 0, 582, 4867, 1, 0, 0, 0, 584, 4873, 1, 0, 0, 0, 586, 4875, 1, 0, 0, - 0, 588, 4883, 1, 0, 0, 0, 590, 4885, 1, 0, 0, 0, 592, 4888, 1, 0, 0, 0, - 594, 4950, 1, 0, 0, 0, 596, 4953, 1, 0, 0, 0, 598, 4957, 1, 0, 0, 0, 600, - 4997, 1, 0, 0, 0, 602, 5011, 1, 0, 0, 0, 604, 5013, 1, 0, 0, 0, 606, 5015, - 1, 0, 0, 0, 608, 5023, 1, 0, 0, 0, 610, 5025, 1, 0, 0, 0, 612, 5033, 1, - 0, 0, 0, 614, 5042, 1, 0, 0, 0, 616, 5046, 1, 0, 0, 0, 618, 5077, 1, 0, - 0, 0, 620, 5079, 1, 0, 0, 0, 622, 5087, 1, 0, 0, 0, 624, 5096, 1, 0, 0, - 0, 626, 5120, 1, 0, 0, 0, 628, 5122, 1, 0, 0, 0, 630, 5138, 1, 0, 0, 0, - 632, 5145, 1, 0, 0, 0, 634, 5147, 1, 0, 0, 0, 636, 5158, 1, 0, 0, 0, 638, - 5165, 1, 0, 0, 0, 640, 5167, 1, 0, 0, 0, 642, 5187, 1, 0, 0, 0, 644, 5189, - 1, 0, 0, 0, 646, 5197, 1, 0, 0, 0, 648, 5208, 1, 0, 0, 0, 650, 5215, 1, - 0, 0, 0, 652, 5217, 1, 0, 0, 0, 654, 5230, 1, 0, 0, 0, 656, 5232, 1, 0, - 0, 0, 658, 5234, 1, 0, 0, 0, 660, 5243, 1, 0, 0, 0, 662, 5245, 1, 0, 0, - 0, 664, 5257, 1, 0, 0, 0, 666, 5262, 1, 0, 0, 0, 668, 5264, 1, 0, 0, 0, - 670, 5266, 1, 0, 0, 0, 672, 674, 3, 2, 1, 0, 673, 672, 1, 0, 0, 0, 674, - 677, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 678, - 1, 0, 0, 0, 677, 675, 1, 0, 0, 0, 678, 679, 5, 0, 0, 1, 679, 1, 1, 0, 0, - 0, 680, 682, 3, 656, 328, 0, 681, 680, 1, 0, 0, 0, 681, 682, 1, 0, 0, 0, - 682, 686, 1, 0, 0, 0, 683, 687, 3, 4, 2, 0, 684, 687, 3, 500, 250, 0, 685, - 687, 3, 560, 280, 0, 686, 683, 1, 0, 0, 0, 686, 684, 1, 0, 0, 0, 686, 685, - 1, 0, 0, 0, 687, 689, 1, 0, 0, 0, 688, 690, 5, 461, 0, 0, 689, 688, 1, - 0, 0, 0, 689, 690, 1, 0, 0, 0, 690, 692, 1, 0, 0, 0, 691, 693, 5, 457, - 0, 0, 692, 691, 1, 0, 0, 0, 692, 693, 1, 0, 0, 0, 693, 3, 1, 0, 0, 0, 694, - 702, 3, 8, 4, 0, 695, 702, 3, 10, 5, 0, 696, 702, 3, 32, 16, 0, 697, 702, - 3, 34, 17, 0, 698, 702, 3, 36, 18, 0, 699, 702, 3, 6, 3, 0, 700, 702, 3, - 38, 19, 0, 701, 694, 1, 0, 0, 0, 701, 695, 1, 0, 0, 0, 701, 696, 1, 0, - 0, 0, 701, 697, 1, 0, 0, 0, 701, 698, 1, 0, 0, 0, 701, 699, 1, 0, 0, 0, - 701, 700, 1, 0, 0, 0, 702, 5, 1, 0, 0, 0, 703, 704, 5, 382, 0, 0, 704, - 705, 5, 185, 0, 0, 705, 706, 5, 47, 0, 0, 706, 711, 3, 510, 255, 0, 707, - 708, 5, 462, 0, 0, 708, 710, 3, 510, 255, 0, 709, 707, 1, 0, 0, 0, 710, - 713, 1, 0, 0, 0, 711, 709, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 714, - 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 714, 715, 5, 71, 0, 0, 715, 720, 3, 508, - 254, 0, 716, 717, 5, 280, 0, 0, 717, 719, 3, 508, 254, 0, 718, 716, 1, - 0, 0, 0, 719, 722, 1, 0, 0, 0, 720, 718, 1, 0, 0, 0, 720, 721, 1, 0, 0, - 0, 721, 728, 1, 0, 0, 0, 722, 720, 1, 0, 0, 0, 723, 726, 5, 284, 0, 0, - 724, 727, 3, 646, 323, 0, 725, 727, 5, 482, 0, 0, 726, 724, 1, 0, 0, 0, - 726, 725, 1, 0, 0, 0, 727, 729, 1, 0, 0, 0, 728, 723, 1, 0, 0, 0, 728, - 729, 1, 0, 0, 0, 729, 732, 1, 0, 0, 0, 730, 731, 5, 420, 0, 0, 731, 733, - 5, 421, 0, 0, 732, 730, 1, 0, 0, 0, 732, 733, 1, 0, 0, 0, 733, 7, 1, 0, - 0, 0, 734, 736, 3, 656, 328, 0, 735, 734, 1, 0, 0, 0, 735, 736, 1, 0, 0, - 0, 736, 740, 1, 0, 0, 0, 737, 739, 3, 658, 329, 0, 738, 737, 1, 0, 0, 0, - 739, 742, 1, 0, 0, 0, 740, 738, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, - 743, 1, 0, 0, 0, 742, 740, 1, 0, 0, 0, 743, 746, 5, 17, 0, 0, 744, 745, - 5, 281, 0, 0, 745, 747, 7, 0, 0, 0, 746, 744, 1, 0, 0, 0, 746, 747, 1, - 0, 0, 0, 747, 767, 1, 0, 0, 0, 748, 768, 3, 80, 40, 0, 749, 768, 3, 112, - 56, 0, 750, 768, 3, 128, 64, 0, 751, 768, 3, 156, 78, 0, 752, 768, 3, 158, - 79, 0, 753, 768, 3, 306, 153, 0, 754, 768, 3, 308, 154, 0, 755, 768, 3, - 134, 67, 0, 756, 768, 3, 146, 73, 0, 757, 768, 3, 412, 206, 0, 758, 768, - 3, 420, 210, 0, 759, 768, 3, 428, 214, 0, 760, 768, 3, 434, 217, 0, 761, - 768, 3, 454, 227, 0, 762, 768, 3, 456, 228, 0, 763, 768, 3, 458, 229, 0, - 764, 768, 3, 478, 239, 0, 765, 768, 3, 480, 240, 0, 766, 768, 3, 486, 243, - 0, 767, 748, 1, 0, 0, 0, 767, 749, 1, 0, 0, 0, 767, 750, 1, 0, 0, 0, 767, - 751, 1, 0, 0, 0, 767, 752, 1, 0, 0, 0, 767, 753, 1, 0, 0, 0, 767, 754, - 1, 0, 0, 0, 767, 755, 1, 0, 0, 0, 767, 756, 1, 0, 0, 0, 767, 757, 1, 0, - 0, 0, 767, 758, 1, 0, 0, 0, 767, 759, 1, 0, 0, 0, 767, 760, 1, 0, 0, 0, - 767, 761, 1, 0, 0, 0, 767, 762, 1, 0, 0, 0, 767, 763, 1, 0, 0, 0, 767, - 764, 1, 0, 0, 0, 767, 765, 1, 0, 0, 0, 767, 766, 1, 0, 0, 0, 768, 9, 1, - 0, 0, 0, 769, 770, 5, 18, 0, 0, 770, 771, 5, 23, 0, 0, 771, 773, 3, 646, - 323, 0, 772, 774, 3, 120, 60, 0, 773, 772, 1, 0, 0, 0, 774, 775, 1, 0, - 0, 0, 775, 773, 1, 0, 0, 0, 775, 776, 1, 0, 0, 0, 776, 865, 1, 0, 0, 0, - 777, 778, 5, 18, 0, 0, 778, 779, 5, 27, 0, 0, 779, 781, 3, 646, 323, 0, - 780, 782, 3, 122, 61, 0, 781, 780, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, - 781, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 865, 1, 0, 0, 0, 785, 786, - 5, 18, 0, 0, 786, 787, 5, 28, 0, 0, 787, 789, 3, 646, 323, 0, 788, 790, - 3, 124, 62, 0, 789, 788, 1, 0, 0, 0, 790, 791, 1, 0, 0, 0, 791, 789, 1, - 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 865, 1, 0, 0, 0, 793, 794, 5, 18, 0, - 0, 794, 795, 5, 36, 0, 0, 795, 797, 3, 646, 323, 0, 796, 798, 3, 126, 63, - 0, 797, 796, 1, 0, 0, 0, 798, 799, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, - 800, 1, 0, 0, 0, 800, 865, 1, 0, 0, 0, 801, 802, 5, 18, 0, 0, 802, 803, - 5, 308, 0, 0, 803, 804, 5, 331, 0, 0, 804, 805, 3, 646, 323, 0, 805, 806, - 5, 47, 0, 0, 806, 811, 3, 464, 232, 0, 807, 808, 5, 462, 0, 0, 808, 810, - 3, 464, 232, 0, 809, 807, 1, 0, 0, 0, 810, 813, 1, 0, 0, 0, 811, 809, 1, - 0, 0, 0, 811, 812, 1, 0, 0, 0, 812, 865, 1, 0, 0, 0, 813, 811, 1, 0, 0, - 0, 814, 815, 5, 18, 0, 0, 815, 816, 5, 308, 0, 0, 816, 817, 5, 306, 0, - 0, 817, 818, 3, 646, 323, 0, 818, 819, 5, 47, 0, 0, 819, 824, 3, 464, 232, - 0, 820, 821, 5, 462, 0, 0, 821, 823, 3, 464, 232, 0, 822, 820, 1, 0, 0, - 0, 823, 826, 1, 0, 0, 0, 824, 822, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, - 865, 1, 0, 0, 0, 826, 824, 1, 0, 0, 0, 827, 828, 5, 18, 0, 0, 828, 829, - 5, 209, 0, 0, 829, 830, 5, 92, 0, 0, 830, 831, 7, 1, 0, 0, 831, 832, 3, - 646, 323, 0, 832, 833, 5, 184, 0, 0, 833, 835, 5, 482, 0, 0, 834, 836, - 3, 12, 6, 0, 835, 834, 1, 0, 0, 0, 836, 837, 1, 0, 0, 0, 837, 835, 1, 0, - 0, 0, 837, 838, 1, 0, 0, 0, 838, 865, 1, 0, 0, 0, 839, 840, 5, 18, 0, 0, - 840, 841, 5, 427, 0, 0, 841, 865, 3, 492, 246, 0, 842, 843, 5, 18, 0, 0, - 843, 844, 5, 33, 0, 0, 844, 845, 3, 646, 323, 0, 845, 847, 5, 466, 0, 0, - 846, 848, 3, 16, 8, 0, 847, 846, 1, 0, 0, 0, 848, 849, 1, 0, 0, 0, 849, - 847, 1, 0, 0, 0, 849, 850, 1, 0, 0, 0, 850, 851, 1, 0, 0, 0, 851, 852, - 5, 467, 0, 0, 852, 865, 1, 0, 0, 0, 853, 854, 5, 18, 0, 0, 854, 855, 5, - 34, 0, 0, 855, 856, 3, 646, 323, 0, 856, 858, 5, 466, 0, 0, 857, 859, 3, - 16, 8, 0, 858, 857, 1, 0, 0, 0, 859, 860, 1, 0, 0, 0, 860, 858, 1, 0, 0, - 0, 860, 861, 1, 0, 0, 0, 861, 862, 1, 0, 0, 0, 862, 863, 5, 467, 0, 0, - 863, 865, 1, 0, 0, 0, 864, 769, 1, 0, 0, 0, 864, 777, 1, 0, 0, 0, 864, - 785, 1, 0, 0, 0, 864, 793, 1, 0, 0, 0, 864, 801, 1, 0, 0, 0, 864, 814, - 1, 0, 0, 0, 864, 827, 1, 0, 0, 0, 864, 839, 1, 0, 0, 0, 864, 842, 1, 0, - 0, 0, 864, 853, 1, 0, 0, 0, 865, 11, 1, 0, 0, 0, 866, 867, 5, 47, 0, 0, - 867, 872, 3, 14, 7, 0, 868, 869, 5, 462, 0, 0, 869, 871, 3, 14, 7, 0, 870, - 868, 1, 0, 0, 0, 871, 874, 1, 0, 0, 0, 872, 870, 1, 0, 0, 0, 872, 873, - 1, 0, 0, 0, 873, 879, 1, 0, 0, 0, 874, 872, 1, 0, 0, 0, 875, 876, 5, 210, - 0, 0, 876, 877, 5, 206, 0, 0, 877, 879, 5, 207, 0, 0, 878, 866, 1, 0, 0, - 0, 878, 875, 1, 0, 0, 0, 879, 13, 1, 0, 0, 0, 880, 881, 5, 203, 0, 0, 881, - 882, 5, 451, 0, 0, 882, 896, 5, 478, 0, 0, 883, 884, 5, 204, 0, 0, 884, - 885, 5, 451, 0, 0, 885, 896, 5, 478, 0, 0, 886, 887, 5, 478, 0, 0, 887, - 888, 5, 451, 0, 0, 888, 896, 5, 478, 0, 0, 889, 890, 5, 478, 0, 0, 890, - 891, 5, 451, 0, 0, 891, 896, 5, 92, 0, 0, 892, 893, 5, 478, 0, 0, 893, - 894, 5, 451, 0, 0, 894, 896, 5, 446, 0, 0, 895, 880, 1, 0, 0, 0, 895, 883, - 1, 0, 0, 0, 895, 886, 1, 0, 0, 0, 895, 889, 1, 0, 0, 0, 895, 892, 1, 0, - 0, 0, 896, 15, 1, 0, 0, 0, 897, 899, 3, 18, 9, 0, 898, 900, 5, 461, 0, - 0, 899, 898, 1, 0, 0, 0, 899, 900, 1, 0, 0, 0, 900, 914, 1, 0, 0, 0, 901, - 903, 3, 22, 11, 0, 902, 904, 5, 461, 0, 0, 903, 902, 1, 0, 0, 0, 903, 904, - 1, 0, 0, 0, 904, 914, 1, 0, 0, 0, 905, 907, 3, 24, 12, 0, 906, 908, 5, - 461, 0, 0, 907, 906, 1, 0, 0, 0, 907, 908, 1, 0, 0, 0, 908, 914, 1, 0, - 0, 0, 909, 911, 3, 26, 13, 0, 910, 912, 5, 461, 0, 0, 911, 910, 1, 0, 0, - 0, 911, 912, 1, 0, 0, 0, 912, 914, 1, 0, 0, 0, 913, 897, 1, 0, 0, 0, 913, - 901, 1, 0, 0, 0, 913, 905, 1, 0, 0, 0, 913, 909, 1, 0, 0, 0, 914, 17, 1, - 0, 0, 0, 915, 916, 5, 47, 0, 0, 916, 917, 3, 20, 10, 0, 917, 918, 5, 92, - 0, 0, 918, 919, 3, 648, 324, 0, 919, 937, 1, 0, 0, 0, 920, 921, 5, 47, - 0, 0, 921, 922, 5, 464, 0, 0, 922, 927, 3, 20, 10, 0, 923, 924, 5, 462, - 0, 0, 924, 926, 3, 20, 10, 0, 925, 923, 1, 0, 0, 0, 926, 929, 1, 0, 0, - 0, 927, 925, 1, 0, 0, 0, 927, 928, 1, 0, 0, 0, 928, 930, 1, 0, 0, 0, 929, - 927, 1, 0, 0, 0, 930, 931, 5, 465, 0, 0, 931, 932, 5, 92, 0, 0, 932, 933, - 3, 648, 324, 0, 933, 937, 1, 0, 0, 0, 934, 935, 5, 47, 0, 0, 935, 937, - 3, 20, 10, 0, 936, 915, 1, 0, 0, 0, 936, 920, 1, 0, 0, 0, 936, 934, 1, - 0, 0, 0, 937, 19, 1, 0, 0, 0, 938, 939, 3, 648, 324, 0, 939, 940, 5, 451, - 0, 0, 940, 941, 3, 404, 202, 0, 941, 946, 1, 0, 0, 0, 942, 943, 5, 478, - 0, 0, 943, 944, 5, 451, 0, 0, 944, 946, 3, 404, 202, 0, 945, 938, 1, 0, - 0, 0, 945, 942, 1, 0, 0, 0, 946, 21, 1, 0, 0, 0, 947, 948, 5, 379, 0, 0, - 948, 949, 5, 381, 0, 0, 949, 950, 3, 648, 324, 0, 950, 951, 5, 466, 0, - 0, 951, 952, 3, 364, 182, 0, 952, 953, 5, 467, 0, 0, 953, 962, 1, 0, 0, - 0, 954, 955, 5, 379, 0, 0, 955, 956, 5, 380, 0, 0, 956, 957, 3, 648, 324, - 0, 957, 958, 5, 466, 0, 0, 958, 959, 3, 364, 182, 0, 959, 960, 5, 467, - 0, 0, 960, 962, 1, 0, 0, 0, 961, 947, 1, 0, 0, 0, 961, 954, 1, 0, 0, 0, - 962, 23, 1, 0, 0, 0, 963, 964, 5, 19, 0, 0, 964, 965, 5, 184, 0, 0, 965, - 970, 3, 648, 324, 0, 966, 967, 5, 462, 0, 0, 967, 969, 3, 648, 324, 0, - 968, 966, 1, 0, 0, 0, 969, 972, 1, 0, 0, 0, 970, 968, 1, 0, 0, 0, 970, - 971, 1, 0, 0, 0, 971, 25, 1, 0, 0, 0, 972, 970, 1, 0, 0, 0, 973, 974, 5, - 414, 0, 0, 974, 975, 3, 648, 324, 0, 975, 976, 5, 137, 0, 0, 976, 977, - 5, 466, 0, 0, 977, 978, 3, 364, 182, 0, 978, 979, 5, 467, 0, 0, 979, 27, - 1, 0, 0, 0, 980, 981, 5, 364, 0, 0, 981, 982, 7, 2, 0, 0, 982, 985, 3, - 646, 323, 0, 983, 984, 5, 413, 0, 0, 984, 986, 3, 646, 323, 0, 985, 983, - 1, 0, 0, 0, 985, 986, 1, 0, 0, 0, 986, 1004, 1, 0, 0, 0, 987, 988, 5, 365, - 0, 0, 988, 989, 5, 33, 0, 0, 989, 1004, 3, 646, 323, 0, 990, 991, 5, 282, - 0, 0, 991, 992, 5, 366, 0, 0, 992, 993, 5, 33, 0, 0, 993, 1004, 3, 646, - 323, 0, 994, 995, 5, 362, 0, 0, 995, 999, 5, 464, 0, 0, 996, 998, 3, 30, - 15, 0, 997, 996, 1, 0, 0, 0, 998, 1001, 1, 0, 0, 0, 999, 997, 1, 0, 0, - 0, 999, 1000, 1, 0, 0, 0, 1000, 1002, 1, 0, 0, 0, 1001, 999, 1, 0, 0, 0, - 1002, 1004, 5, 465, 0, 0, 1003, 980, 1, 0, 0, 0, 1003, 987, 1, 0, 0, 0, - 1003, 990, 1, 0, 0, 0, 1003, 994, 1, 0, 0, 0, 1004, 29, 1, 0, 0, 0, 1005, - 1006, 5, 362, 0, 0, 1006, 1007, 5, 154, 0, 0, 1007, 1012, 5, 478, 0, 0, - 1008, 1009, 5, 33, 0, 0, 1009, 1013, 3, 646, 323, 0, 1010, 1011, 5, 30, - 0, 0, 1011, 1013, 3, 646, 323, 0, 1012, 1008, 1, 0, 0, 0, 1012, 1010, 1, - 0, 0, 0, 1012, 1013, 1, 0, 0, 0, 1013, 1015, 1, 0, 0, 0, 1014, 1016, 5, - 461, 0, 0, 1015, 1014, 1, 0, 0, 0, 1015, 1016, 1, 0, 0, 0, 1016, 1031, - 1, 0, 0, 0, 1017, 1018, 5, 362, 0, 0, 1018, 1019, 5, 478, 0, 0, 1019, 1023, - 5, 464, 0, 0, 1020, 1022, 3, 30, 15, 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, 5, 465, 0, 0, 1027, 1029, - 5, 461, 0, 0, 1028, 1027, 1, 0, 0, 0, 1028, 1029, 1, 0, 0, 0, 1029, 1031, - 1, 0, 0, 0, 1030, 1005, 1, 0, 0, 0, 1030, 1017, 1, 0, 0, 0, 1031, 31, 1, - 0, 0, 0, 1032, 1033, 5, 19, 0, 0, 1033, 1034, 5, 23, 0, 0, 1034, 1086, - 3, 646, 323, 0, 1035, 1036, 5, 19, 0, 0, 1036, 1037, 5, 27, 0, 0, 1037, - 1086, 3, 646, 323, 0, 1038, 1039, 5, 19, 0, 0, 1039, 1040, 5, 28, 0, 0, - 1040, 1086, 3, 646, 323, 0, 1041, 1042, 5, 19, 0, 0, 1042, 1043, 5, 37, - 0, 0, 1043, 1086, 3, 646, 323, 0, 1044, 1045, 5, 19, 0, 0, 1045, 1046, - 5, 30, 0, 0, 1046, 1086, 3, 646, 323, 0, 1047, 1048, 5, 19, 0, 0, 1048, - 1049, 5, 31, 0, 0, 1049, 1086, 3, 646, 323, 0, 1050, 1051, 5, 19, 0, 0, - 1051, 1052, 5, 33, 0, 0, 1052, 1086, 3, 646, 323, 0, 1053, 1054, 5, 19, - 0, 0, 1054, 1055, 5, 34, 0, 0, 1055, 1086, 3, 646, 323, 0, 1056, 1057, - 5, 19, 0, 0, 1057, 1058, 5, 29, 0, 0, 1058, 1086, 3, 646, 323, 0, 1059, - 1060, 5, 19, 0, 0, 1060, 1061, 5, 36, 0, 0, 1061, 1086, 3, 646, 323, 0, - 1062, 1063, 5, 19, 0, 0, 1063, 1064, 5, 113, 0, 0, 1064, 1065, 5, 114, - 0, 0, 1065, 1086, 3, 646, 323, 0, 1066, 1067, 5, 19, 0, 0, 1067, 1068, - 5, 41, 0, 0, 1068, 1069, 3, 646, 323, 0, 1069, 1070, 5, 92, 0, 0, 1070, - 1071, 3, 646, 323, 0, 1071, 1086, 1, 0, 0, 0, 1072, 1073, 5, 19, 0, 0, - 1073, 1074, 5, 308, 0, 0, 1074, 1075, 5, 331, 0, 0, 1075, 1086, 3, 646, - 323, 0, 1076, 1077, 5, 19, 0, 0, 1077, 1078, 5, 308, 0, 0, 1078, 1079, - 5, 306, 0, 0, 1079, 1086, 3, 646, 323, 0, 1080, 1081, 5, 19, 0, 0, 1081, - 1082, 5, 424, 0, 0, 1082, 1083, 5, 425, 0, 0, 1083, 1084, 5, 306, 0, 0, - 1084, 1086, 3, 646, 323, 0, 1085, 1032, 1, 0, 0, 0, 1085, 1035, 1, 0, 0, - 0, 1085, 1038, 1, 0, 0, 0, 1085, 1041, 1, 0, 0, 0, 1085, 1044, 1, 0, 0, - 0, 1085, 1047, 1, 0, 0, 0, 1085, 1050, 1, 0, 0, 0, 1085, 1053, 1, 0, 0, - 0, 1085, 1056, 1, 0, 0, 0, 1085, 1059, 1, 0, 0, 0, 1085, 1062, 1, 0, 0, - 0, 1085, 1066, 1, 0, 0, 0, 1085, 1072, 1, 0, 0, 0, 1085, 1076, 1, 0, 0, - 0, 1085, 1080, 1, 0, 0, 0, 1086, 33, 1, 0, 0, 0, 1087, 1088, 5, 20, 0, - 0, 1088, 1089, 5, 23, 0, 0, 1089, 1090, 3, 646, 323, 0, 1090, 1091, 5, - 410, 0, 0, 1091, 1092, 5, 482, 0, 0, 1092, 1099, 1, 0, 0, 0, 1093, 1094, - 5, 20, 0, 0, 1094, 1095, 5, 29, 0, 0, 1095, 1096, 5, 482, 0, 0, 1096, 1097, - 5, 410, 0, 0, 1097, 1099, 5, 482, 0, 0, 1098, 1087, 1, 0, 0, 0, 1098, 1093, - 1, 0, 0, 0, 1099, 35, 1, 0, 0, 0, 1100, 1109, 5, 21, 0, 0, 1101, 1110, - 5, 33, 0, 0, 1102, 1110, 5, 30, 0, 0, 1103, 1110, 5, 34, 0, 0, 1104, 1110, - 5, 31, 0, 0, 1105, 1110, 5, 28, 0, 0, 1106, 1110, 5, 37, 0, 0, 1107, 1108, - 5, 343, 0, 0, 1108, 1110, 5, 342, 0, 0, 1109, 1101, 1, 0, 0, 0, 1109, 1102, - 1, 0, 0, 0, 1109, 1103, 1, 0, 0, 0, 1109, 1104, 1, 0, 0, 0, 1109, 1105, - 1, 0, 0, 0, 1109, 1106, 1, 0, 0, 0, 1109, 1107, 1, 0, 0, 0, 1110, 1111, - 1, 0, 0, 0, 1111, 1112, 3, 646, 323, 0, 1112, 1113, 5, 410, 0, 0, 1113, - 1114, 5, 215, 0, 0, 1114, 1120, 5, 478, 0, 0, 1115, 1118, 5, 284, 0, 0, - 1116, 1119, 3, 646, 323, 0, 1117, 1119, 5, 482, 0, 0, 1118, 1116, 1, 0, - 0, 0, 1118, 1117, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1115, 1, 0, - 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1148, 1, 0, 0, 0, 1122, 1131, 5, 21, - 0, 0, 1123, 1132, 5, 33, 0, 0, 1124, 1132, 5, 30, 0, 0, 1125, 1132, 5, - 34, 0, 0, 1126, 1132, 5, 31, 0, 0, 1127, 1132, 5, 28, 0, 0, 1128, 1132, - 5, 37, 0, 0, 1129, 1130, 5, 343, 0, 0, 1130, 1132, 5, 342, 0, 0, 1131, - 1123, 1, 0, 0, 0, 1131, 1124, 1, 0, 0, 0, 1131, 1125, 1, 0, 0, 0, 1131, - 1126, 1, 0, 0, 0, 1131, 1127, 1, 0, 0, 0, 1131, 1128, 1, 0, 0, 0, 1131, - 1129, 1, 0, 0, 0, 1132, 1133, 1, 0, 0, 0, 1133, 1134, 3, 646, 323, 0, 1134, - 1137, 5, 410, 0, 0, 1135, 1138, 3, 646, 323, 0, 1136, 1138, 5, 482, 0, - 0, 1137, 1135, 1, 0, 0, 0, 1137, 1136, 1, 0, 0, 0, 1138, 1148, 1, 0, 0, - 0, 1139, 1140, 5, 21, 0, 0, 1140, 1141, 5, 23, 0, 0, 1141, 1142, 3, 646, - 323, 0, 1142, 1145, 5, 410, 0, 0, 1143, 1146, 3, 646, 323, 0, 1144, 1146, - 5, 482, 0, 0, 1145, 1143, 1, 0, 0, 0, 1145, 1144, 1, 0, 0, 0, 1146, 1148, - 1, 0, 0, 0, 1147, 1100, 1, 0, 0, 0, 1147, 1122, 1, 0, 0, 0, 1147, 1139, - 1, 0, 0, 0, 1148, 37, 1, 0, 0, 0, 1149, 1167, 3, 40, 20, 0, 1150, 1167, - 3, 42, 21, 0, 1151, 1167, 3, 44, 22, 0, 1152, 1167, 3, 46, 23, 0, 1153, - 1167, 3, 48, 24, 0, 1154, 1167, 3, 50, 25, 0, 1155, 1167, 3, 52, 26, 0, - 1156, 1167, 3, 54, 27, 0, 1157, 1167, 3, 56, 28, 0, 1158, 1167, 3, 58, - 29, 0, 1159, 1167, 3, 60, 30, 0, 1160, 1167, 3, 62, 31, 0, 1161, 1167, - 3, 64, 32, 0, 1162, 1167, 3, 66, 33, 0, 1163, 1167, 3, 68, 34, 0, 1164, - 1167, 3, 70, 35, 0, 1165, 1167, 3, 72, 36, 0, 1166, 1149, 1, 0, 0, 0, 1166, - 1150, 1, 0, 0, 0, 1166, 1151, 1, 0, 0, 0, 1166, 1152, 1, 0, 0, 0, 1166, - 1153, 1, 0, 0, 0, 1166, 1154, 1, 0, 0, 0, 1166, 1155, 1, 0, 0, 0, 1166, - 1156, 1, 0, 0, 0, 1166, 1157, 1, 0, 0, 0, 1166, 1158, 1, 0, 0, 0, 1166, - 1159, 1, 0, 0, 0, 1166, 1160, 1, 0, 0, 0, 1166, 1161, 1, 0, 0, 0, 1166, - 1162, 1, 0, 0, 0, 1166, 1163, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1166, - 1165, 1, 0, 0, 0, 1167, 39, 1, 0, 0, 0, 1168, 1169, 5, 17, 0, 0, 1169, - 1170, 5, 29, 0, 0, 1170, 1171, 5, 430, 0, 0, 1171, 1174, 3, 646, 323, 0, - 1172, 1173, 5, 445, 0, 0, 1173, 1175, 5, 478, 0, 0, 1174, 1172, 1, 0, 0, - 0, 1174, 1175, 1, 0, 0, 0, 1175, 41, 1, 0, 0, 0, 1176, 1177, 5, 19, 0, - 0, 1177, 1178, 5, 29, 0, 0, 1178, 1179, 5, 430, 0, 0, 1179, 1180, 3, 646, - 323, 0, 1180, 43, 1, 0, 0, 0, 1181, 1182, 5, 17, 0, 0, 1182, 1183, 5, 442, - 0, 0, 1183, 1184, 5, 430, 0, 0, 1184, 1185, 3, 648, 324, 0, 1185, 1186, - 5, 464, 0, 0, 1186, 1187, 3, 74, 37, 0, 1187, 1191, 5, 465, 0, 0, 1188, - 1189, 5, 436, 0, 0, 1189, 1190, 5, 84, 0, 0, 1190, 1192, 5, 431, 0, 0, - 1191, 1188, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 45, 1, 0, 0, 0, 1193, - 1194, 5, 18, 0, 0, 1194, 1195, 5, 442, 0, 0, 1195, 1196, 5, 430, 0, 0, - 1196, 1197, 3, 648, 324, 0, 1197, 1198, 5, 46, 0, 0, 1198, 1199, 5, 29, - 0, 0, 1199, 1200, 5, 431, 0, 0, 1200, 1201, 5, 464, 0, 0, 1201, 1202, 3, - 74, 37, 0, 1202, 1203, 5, 465, 0, 0, 1203, 1216, 1, 0, 0, 0, 1204, 1205, - 5, 18, 0, 0, 1205, 1206, 5, 442, 0, 0, 1206, 1207, 5, 430, 0, 0, 1207, - 1208, 3, 648, 324, 0, 1208, 1209, 5, 131, 0, 0, 1209, 1210, 5, 29, 0, 0, - 1210, 1211, 5, 431, 0, 0, 1211, 1212, 5, 464, 0, 0, 1212, 1213, 3, 74, - 37, 0, 1213, 1214, 5, 465, 0, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1193, 1, - 0, 0, 0, 1215, 1204, 1, 0, 0, 0, 1216, 47, 1, 0, 0, 0, 1217, 1218, 5, 19, - 0, 0, 1218, 1219, 5, 442, 0, 0, 1219, 1220, 5, 430, 0, 0, 1220, 1221, 3, - 648, 324, 0, 1221, 49, 1, 0, 0, 0, 1222, 1223, 5, 432, 0, 0, 1223, 1224, - 3, 74, 37, 0, 1224, 1225, 5, 92, 0, 0, 1225, 1226, 3, 646, 323, 0, 1226, - 1227, 5, 464, 0, 0, 1227, 1228, 3, 76, 38, 0, 1228, 1231, 5, 465, 0, 0, - 1229, 1230, 5, 71, 0, 0, 1230, 1232, 5, 478, 0, 0, 1231, 1229, 1, 0, 0, - 0, 1231, 1232, 1, 0, 0, 0, 1232, 51, 1, 0, 0, 0, 1233, 1234, 5, 433, 0, - 0, 1234, 1235, 3, 74, 37, 0, 1235, 1236, 5, 92, 0, 0, 1236, 1237, 3, 646, - 323, 0, 1237, 53, 1, 0, 0, 0, 1238, 1239, 5, 432, 0, 0, 1239, 1240, 5, - 386, 0, 0, 1240, 1241, 5, 92, 0, 0, 1241, 1242, 5, 30, 0, 0, 1242, 1243, - 3, 646, 323, 0, 1243, 1244, 5, 410, 0, 0, 1244, 1245, 3, 74, 37, 0, 1245, - 55, 1, 0, 0, 0, 1246, 1247, 5, 433, 0, 0, 1247, 1248, 5, 386, 0, 0, 1248, - 1249, 5, 92, 0, 0, 1249, 1250, 5, 30, 0, 0, 1250, 1251, 3, 646, 323, 0, - 1251, 1252, 5, 70, 0, 0, 1252, 1253, 3, 74, 37, 0, 1253, 57, 1, 0, 0, 0, - 1254, 1255, 5, 432, 0, 0, 1255, 1256, 5, 25, 0, 0, 1256, 1257, 5, 92, 0, - 0, 1257, 1258, 5, 33, 0, 0, 1258, 1259, 3, 646, 323, 0, 1259, 1260, 5, - 410, 0, 0, 1260, 1261, 3, 74, 37, 0, 1261, 59, 1, 0, 0, 0, 1262, 1263, - 5, 433, 0, 0, 1263, 1264, 5, 25, 0, 0, 1264, 1265, 5, 92, 0, 0, 1265, 1266, - 5, 33, 0, 0, 1266, 1267, 3, 646, 323, 0, 1267, 1268, 5, 70, 0, 0, 1268, - 1269, 3, 74, 37, 0, 1269, 61, 1, 0, 0, 0, 1270, 1271, 5, 432, 0, 0, 1271, - 1272, 5, 440, 0, 0, 1272, 1273, 5, 92, 0, 0, 1273, 1274, 5, 308, 0, 0, - 1274, 1275, 5, 306, 0, 0, 1275, 1276, 3, 646, 323, 0, 1276, 1277, 5, 410, - 0, 0, 1277, 1278, 3, 74, 37, 0, 1278, 63, 1, 0, 0, 0, 1279, 1280, 5, 433, - 0, 0, 1280, 1281, 5, 440, 0, 0, 1281, 1282, 5, 92, 0, 0, 1282, 1283, 5, - 308, 0, 0, 1283, 1284, 5, 306, 0, 0, 1284, 1285, 3, 646, 323, 0, 1285, - 1286, 5, 70, 0, 0, 1286, 1287, 3, 74, 37, 0, 1287, 65, 1, 0, 0, 0, 1288, - 1289, 5, 18, 0, 0, 1289, 1290, 5, 58, 0, 0, 1290, 1291, 5, 429, 0, 0, 1291, - 1292, 5, 441, 0, 0, 1292, 1300, 7, 3, 0, 0, 1293, 1294, 5, 18, 0, 0, 1294, - 1295, 5, 58, 0, 0, 1295, 1296, 5, 429, 0, 0, 1296, 1297, 5, 437, 0, 0, - 1297, 1298, 5, 447, 0, 0, 1298, 1300, 7, 4, 0, 0, 1299, 1288, 1, 0, 0, - 0, 1299, 1293, 1, 0, 0, 0, 1300, 67, 1, 0, 0, 0, 1301, 1302, 5, 17, 0, - 0, 1302, 1303, 5, 437, 0, 0, 1303, 1304, 5, 442, 0, 0, 1304, 1305, 5, 478, - 0, 0, 1305, 1306, 5, 341, 0, 0, 1306, 1307, 5, 478, 0, 0, 1307, 1308, 5, - 464, 0, 0, 1308, 1313, 3, 648, 324, 0, 1309, 1310, 5, 462, 0, 0, 1310, - 1312, 3, 648, 324, 0, 1311, 1309, 1, 0, 0, 0, 1312, 1315, 1, 0, 0, 0, 1313, - 1311, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, 1316, 1, 0, 0, 0, 1315, - 1313, 1, 0, 0, 0, 1316, 1317, 5, 465, 0, 0, 1317, 69, 1, 0, 0, 0, 1318, - 1319, 5, 19, 0, 0, 1319, 1320, 5, 437, 0, 0, 1320, 1321, 5, 442, 0, 0, - 1321, 1322, 5, 478, 0, 0, 1322, 71, 1, 0, 0, 0, 1323, 1324, 5, 382, 0, - 0, 1324, 1327, 5, 429, 0, 0, 1325, 1326, 5, 284, 0, 0, 1326, 1328, 3, 646, - 323, 0, 1327, 1325, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, 73, 1, 0, - 0, 0, 1329, 1334, 3, 646, 323, 0, 1330, 1331, 5, 462, 0, 0, 1331, 1333, - 3, 646, 323, 0, 1332, 1330, 1, 0, 0, 0, 1333, 1336, 1, 0, 0, 0, 1334, 1332, - 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 75, 1, 0, 0, 0, 1336, 1334, 1, - 0, 0, 0, 1337, 1342, 3, 78, 39, 0, 1338, 1339, 5, 462, 0, 0, 1339, 1341, - 3, 78, 39, 0, 1340, 1338, 1, 0, 0, 0, 1341, 1344, 1, 0, 0, 0, 1342, 1340, - 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 77, 1, 0, 0, 0, 1344, 1342, 1, - 0, 0, 0, 1345, 1374, 5, 17, 0, 0, 1346, 1374, 5, 99, 0, 0, 1347, 1348, - 5, 443, 0, 0, 1348, 1374, 5, 456, 0, 0, 1349, 1350, 5, 443, 0, 0, 1350, - 1351, 5, 464, 0, 0, 1351, 1356, 5, 482, 0, 0, 1352, 1353, 5, 462, 0, 0, - 1353, 1355, 5, 482, 0, 0, 1354, 1352, 1, 0, 0, 0, 1355, 1358, 1, 0, 0, - 0, 1356, 1354, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 1359, 1, 0, 0, - 0, 1358, 1356, 1, 0, 0, 0, 1359, 1374, 5, 465, 0, 0, 1360, 1361, 5, 444, - 0, 0, 1361, 1374, 5, 456, 0, 0, 1362, 1363, 5, 444, 0, 0, 1363, 1364, 5, - 464, 0, 0, 1364, 1369, 5, 482, 0, 0, 1365, 1366, 5, 462, 0, 0, 1366, 1368, - 5, 482, 0, 0, 1367, 1365, 1, 0, 0, 0, 1368, 1371, 1, 0, 0, 0, 1369, 1367, - 1, 0, 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 1372, 1, 0, 0, 0, 1371, 1369, - 1, 0, 0, 0, 1372, 1374, 5, 465, 0, 0, 1373, 1345, 1, 0, 0, 0, 1373, 1346, - 1, 0, 0, 0, 1373, 1347, 1, 0, 0, 0, 1373, 1349, 1, 0, 0, 0, 1373, 1360, - 1, 0, 0, 0, 1373, 1362, 1, 0, 0, 0, 1374, 79, 1, 0, 0, 0, 1375, 1376, 5, - 24, 0, 0, 1376, 1377, 5, 23, 0, 0, 1377, 1379, 3, 646, 323, 0, 1378, 1380, - 3, 82, 41, 0, 1379, 1378, 1, 0, 0, 0, 1379, 1380, 1, 0, 0, 0, 1380, 1382, - 1, 0, 0, 0, 1381, 1383, 3, 84, 42, 0, 1382, 1381, 1, 0, 0, 0, 1382, 1383, - 1, 0, 0, 0, 1383, 1422, 1, 0, 0, 0, 1384, 1385, 5, 11, 0, 0, 1385, 1386, - 5, 23, 0, 0, 1386, 1388, 3, 646, 323, 0, 1387, 1389, 3, 82, 41, 0, 1388, - 1387, 1, 0, 0, 0, 1388, 1389, 1, 0, 0, 0, 1389, 1391, 1, 0, 0, 0, 1390, - 1392, 3, 84, 42, 0, 1391, 1390, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, - 1422, 1, 0, 0, 0, 1393, 1394, 5, 25, 0, 0, 1394, 1395, 5, 23, 0, 0, 1395, - 1397, 3, 646, 323, 0, 1396, 1398, 3, 84, 42, 0, 1397, 1396, 1, 0, 0, 0, - 1397, 1398, 1, 0, 0, 0, 1398, 1399, 1, 0, 0, 0, 1399, 1401, 5, 75, 0, 0, - 1400, 1402, 5, 464, 0, 0, 1401, 1400, 1, 0, 0, 0, 1401, 1402, 1, 0, 0, - 0, 1402, 1403, 1, 0, 0, 0, 1403, 1405, 3, 522, 261, 0, 1404, 1406, 5, 465, - 0, 0, 1405, 1404, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1422, 1, 0, - 0, 0, 1407, 1408, 5, 26, 0, 0, 1408, 1409, 5, 23, 0, 0, 1409, 1411, 3, - 646, 323, 0, 1410, 1412, 3, 84, 42, 0, 1411, 1410, 1, 0, 0, 0, 1411, 1412, - 1, 0, 0, 0, 1412, 1422, 1, 0, 0, 0, 1413, 1414, 5, 23, 0, 0, 1414, 1416, - 3, 646, 323, 0, 1415, 1417, 3, 82, 41, 0, 1416, 1415, 1, 0, 0, 0, 1416, - 1417, 1, 0, 0, 0, 1417, 1419, 1, 0, 0, 0, 1418, 1420, 3, 84, 42, 0, 1419, - 1418, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1422, 1, 0, 0, 0, 1421, - 1375, 1, 0, 0, 0, 1421, 1384, 1, 0, 0, 0, 1421, 1393, 1, 0, 0, 0, 1421, - 1407, 1, 0, 0, 0, 1421, 1413, 1, 0, 0, 0, 1422, 81, 1, 0, 0, 0, 1423, 1424, - 5, 45, 0, 0, 1424, 1428, 3, 646, 323, 0, 1425, 1426, 5, 44, 0, 0, 1426, - 1428, 3, 646, 323, 0, 1427, 1423, 1, 0, 0, 0, 1427, 1425, 1, 0, 0, 0, 1428, - 83, 1, 0, 0, 0, 1429, 1431, 5, 464, 0, 0, 1430, 1432, 3, 90, 45, 0, 1431, - 1430, 1, 0, 0, 0, 1431, 1432, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, - 1435, 5, 465, 0, 0, 1434, 1436, 3, 86, 43, 0, 1435, 1434, 1, 0, 0, 0, 1435, - 1436, 1, 0, 0, 0, 1436, 1439, 1, 0, 0, 0, 1437, 1439, 3, 86, 43, 0, 1438, - 1429, 1, 0, 0, 0, 1438, 1437, 1, 0, 0, 0, 1439, 85, 1, 0, 0, 0, 1440, 1447, - 3, 88, 44, 0, 1441, 1443, 5, 462, 0, 0, 1442, 1441, 1, 0, 0, 0, 1442, 1443, - 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 1446, 3, 88, 44, 0, 1445, 1442, - 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447, 1445, 1, 0, 0, 0, 1447, 1448, - 1, 0, 0, 0, 1448, 87, 1, 0, 0, 0, 1449, 1447, 1, 0, 0, 0, 1450, 1451, 5, - 393, 0, 0, 1451, 1455, 5, 478, 0, 0, 1452, 1453, 5, 41, 0, 0, 1453, 1455, - 3, 104, 52, 0, 1454, 1450, 1, 0, 0, 0, 1454, 1452, 1, 0, 0, 0, 1455, 89, - 1, 0, 0, 0, 1456, 1461, 3, 92, 46, 0, 1457, 1458, 5, 462, 0, 0, 1458, 1460, - 3, 92, 46, 0, 1459, 1457, 1, 0, 0, 0, 1460, 1463, 1, 0, 0, 0, 1461, 1459, - 1, 0, 0, 0, 1461, 1462, 1, 0, 0, 0, 1462, 91, 1, 0, 0, 0, 1463, 1461, 1, - 0, 0, 0, 1464, 1466, 3, 656, 328, 0, 1465, 1464, 1, 0, 0, 0, 1465, 1466, - 1, 0, 0, 0, 1466, 1470, 1, 0, 0, 0, 1467, 1469, 3, 658, 329, 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, 1474, - 3, 94, 47, 0, 1474, 1475, 5, 470, 0, 0, 1475, 1479, 3, 98, 49, 0, 1476, - 1478, 3, 96, 48, 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, 93, 1, 0, 0, 0, 1481, 1479, - 1, 0, 0, 0, 1482, 1486, 5, 482, 0, 0, 1483, 1486, 5, 484, 0, 0, 1484, 1486, - 3, 668, 334, 0, 1485, 1482, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1484, - 1, 0, 0, 0, 1486, 95, 1, 0, 0, 0, 1487, 1490, 5, 7, 0, 0, 1488, 1489, 5, - 297, 0, 0, 1489, 1491, 5, 478, 0, 0, 1490, 1488, 1, 0, 0, 0, 1490, 1491, - 1, 0, 0, 0, 1491, 1514, 1, 0, 0, 0, 1492, 1493, 5, 282, 0, 0, 1493, 1496, - 5, 283, 0, 0, 1494, 1495, 5, 297, 0, 0, 1495, 1497, 5, 478, 0, 0, 1496, - 1494, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, 1514, 1, 0, 0, 0, 1498, - 1501, 5, 289, 0, 0, 1499, 1500, 5, 297, 0, 0, 1500, 1502, 5, 478, 0, 0, - 1501, 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1514, 1, 0, 0, 0, - 1503, 1506, 5, 290, 0, 0, 1504, 1507, 3, 650, 325, 0, 1505, 1507, 3, 608, - 304, 0, 1506, 1504, 1, 0, 0, 0, 1506, 1505, 1, 0, 0, 0, 1507, 1514, 1, - 0, 0, 0, 1508, 1511, 5, 296, 0, 0, 1509, 1510, 5, 297, 0, 0, 1510, 1512, - 5, 478, 0, 0, 1511, 1509, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1514, - 1, 0, 0, 0, 1513, 1487, 1, 0, 0, 0, 1513, 1492, 1, 0, 0, 0, 1513, 1498, - 1, 0, 0, 0, 1513, 1503, 1, 0, 0, 0, 1513, 1508, 1, 0, 0, 0, 1514, 97, 1, - 0, 0, 0, 1515, 1519, 5, 257, 0, 0, 1516, 1517, 5, 464, 0, 0, 1517, 1518, - 5, 480, 0, 0, 1518, 1520, 5, 465, 0, 0, 1519, 1516, 1, 0, 0, 0, 1519, 1520, - 1, 0, 0, 0, 1520, 1552, 1, 0, 0, 0, 1521, 1552, 5, 258, 0, 0, 1522, 1552, - 5, 259, 0, 0, 1523, 1552, 5, 260, 0, 0, 1524, 1552, 5, 261, 0, 0, 1525, - 1552, 5, 262, 0, 0, 1526, 1552, 5, 263, 0, 0, 1527, 1552, 5, 264, 0, 0, - 1528, 1552, 5, 265, 0, 0, 1529, 1552, 5, 266, 0, 0, 1530, 1552, 5, 267, - 0, 0, 1531, 1552, 5, 268, 0, 0, 1532, 1533, 5, 269, 0, 0, 1533, 1534, 5, - 464, 0, 0, 1534, 1535, 3, 100, 50, 0, 1535, 1536, 5, 465, 0, 0, 1536, 1552, - 1, 0, 0, 0, 1537, 1538, 5, 23, 0, 0, 1538, 1539, 5, 452, 0, 0, 1539, 1540, - 5, 482, 0, 0, 1540, 1552, 5, 453, 0, 0, 1541, 1542, 5, 270, 0, 0, 1542, - 1552, 3, 646, 323, 0, 1543, 1544, 5, 28, 0, 0, 1544, 1545, 5, 464, 0, 0, - 1545, 1546, 3, 646, 323, 0, 1546, 1547, 5, 465, 0, 0, 1547, 1552, 1, 0, - 0, 0, 1548, 1549, 5, 13, 0, 0, 1549, 1552, 3, 646, 323, 0, 1550, 1552, - 3, 646, 323, 0, 1551, 1515, 1, 0, 0, 0, 1551, 1521, 1, 0, 0, 0, 1551, 1522, - 1, 0, 0, 0, 1551, 1523, 1, 0, 0, 0, 1551, 1524, 1, 0, 0, 0, 1551, 1525, - 1, 0, 0, 0, 1551, 1526, 1, 0, 0, 0, 1551, 1527, 1, 0, 0, 0, 1551, 1528, - 1, 0, 0, 0, 1551, 1529, 1, 0, 0, 0, 1551, 1530, 1, 0, 0, 0, 1551, 1531, - 1, 0, 0, 0, 1551, 1532, 1, 0, 0, 0, 1551, 1537, 1, 0, 0, 0, 1551, 1541, - 1, 0, 0, 0, 1551, 1543, 1, 0, 0, 0, 1551, 1548, 1, 0, 0, 0, 1551, 1550, - 1, 0, 0, 0, 1552, 99, 1, 0, 0, 0, 1553, 1554, 7, 5, 0, 0, 1554, 101, 1, - 0, 0, 0, 1555, 1559, 5, 257, 0, 0, 1556, 1557, 5, 464, 0, 0, 1557, 1558, - 5, 480, 0, 0, 1558, 1560, 5, 465, 0, 0, 1559, 1556, 1, 0, 0, 0, 1559, 1560, - 1, 0, 0, 0, 1560, 1581, 1, 0, 0, 0, 1561, 1581, 5, 258, 0, 0, 1562, 1581, - 5, 259, 0, 0, 1563, 1581, 5, 260, 0, 0, 1564, 1581, 5, 261, 0, 0, 1565, - 1581, 5, 262, 0, 0, 1566, 1581, 5, 263, 0, 0, 1567, 1581, 5, 264, 0, 0, - 1568, 1581, 5, 265, 0, 0, 1569, 1581, 5, 266, 0, 0, 1570, 1581, 5, 267, - 0, 0, 1571, 1581, 5, 268, 0, 0, 1572, 1573, 5, 270, 0, 0, 1573, 1581, 3, - 646, 323, 0, 1574, 1575, 5, 28, 0, 0, 1575, 1576, 5, 464, 0, 0, 1576, 1577, - 3, 646, 323, 0, 1577, 1578, 5, 465, 0, 0, 1578, 1581, 1, 0, 0, 0, 1579, - 1581, 3, 646, 323, 0, 1580, 1555, 1, 0, 0, 0, 1580, 1561, 1, 0, 0, 0, 1580, - 1562, 1, 0, 0, 0, 1580, 1563, 1, 0, 0, 0, 1580, 1564, 1, 0, 0, 0, 1580, - 1565, 1, 0, 0, 0, 1580, 1566, 1, 0, 0, 0, 1580, 1567, 1, 0, 0, 0, 1580, - 1568, 1, 0, 0, 0, 1580, 1569, 1, 0, 0, 0, 1580, 1570, 1, 0, 0, 0, 1580, - 1571, 1, 0, 0, 0, 1580, 1572, 1, 0, 0, 0, 1580, 1574, 1, 0, 0, 0, 1580, - 1579, 1, 0, 0, 0, 1581, 103, 1, 0, 0, 0, 1582, 1584, 5, 482, 0, 0, 1583, - 1582, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, - 1586, 5, 464, 0, 0, 1586, 1587, 3, 106, 53, 0, 1587, 1588, 5, 465, 0, 0, - 1588, 105, 1, 0, 0, 0, 1589, 1594, 3, 108, 54, 0, 1590, 1591, 5, 462, 0, - 0, 1591, 1593, 3, 108, 54, 0, 1592, 1590, 1, 0, 0, 0, 1593, 1596, 1, 0, - 0, 0, 1594, 1592, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 107, 1, 0, - 0, 0, 1596, 1594, 1, 0, 0, 0, 1597, 1599, 3, 110, 55, 0, 1598, 1600, 7, - 6, 0, 0, 1599, 1598, 1, 0, 0, 0, 1599, 1600, 1, 0, 0, 0, 1600, 109, 1, - 0, 0, 0, 1601, 1605, 5, 482, 0, 0, 1602, 1605, 5, 484, 0, 0, 1603, 1605, - 3, 668, 334, 0, 1604, 1601, 1, 0, 0, 0, 1604, 1602, 1, 0, 0, 0, 1604, 1603, - 1, 0, 0, 0, 1605, 111, 1, 0, 0, 0, 1606, 1607, 5, 27, 0, 0, 1607, 1608, - 3, 646, 323, 0, 1608, 1609, 5, 70, 0, 0, 1609, 1610, 3, 646, 323, 0, 1610, - 1611, 5, 410, 0, 0, 1611, 1613, 3, 646, 323, 0, 1612, 1614, 3, 114, 57, - 0, 1613, 1612, 1, 0, 0, 0, 1613, 1614, 1, 0, 0, 0, 1614, 113, 1, 0, 0, - 0, 1615, 1617, 3, 116, 58, 0, 1616, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, - 0, 0, 1618, 1616, 1, 0, 0, 0, 1618, 1619, 1, 0, 0, 0, 1619, 115, 1, 0, - 0, 0, 1620, 1621, 5, 404, 0, 0, 1621, 1631, 7, 7, 0, 0, 1622, 1623, 5, - 42, 0, 0, 1623, 1631, 7, 8, 0, 0, 1624, 1625, 5, 50, 0, 0, 1625, 1631, - 7, 9, 0, 0, 1626, 1627, 5, 52, 0, 0, 1627, 1631, 3, 118, 59, 0, 1628, 1629, - 5, 393, 0, 0, 1629, 1631, 5, 478, 0, 0, 1630, 1620, 1, 0, 0, 0, 1630, 1622, - 1, 0, 0, 0, 1630, 1624, 1, 0, 0, 0, 1630, 1626, 1, 0, 0, 0, 1630, 1628, - 1, 0, 0, 0, 1631, 117, 1, 0, 0, 0, 1632, 1633, 7, 10, 0, 0, 1633, 119, - 1, 0, 0, 0, 1634, 1635, 5, 46, 0, 0, 1635, 1636, 5, 38, 0, 0, 1636, 1691, - 3, 92, 46, 0, 1637, 1638, 5, 46, 0, 0, 1638, 1639, 5, 39, 0, 0, 1639, 1691, - 3, 92, 46, 0, 1640, 1641, 5, 20, 0, 0, 1641, 1642, 5, 38, 0, 0, 1642, 1643, - 3, 94, 47, 0, 1643, 1644, 5, 410, 0, 0, 1644, 1645, 3, 94, 47, 0, 1645, - 1691, 1, 0, 0, 0, 1646, 1647, 5, 20, 0, 0, 1647, 1648, 5, 39, 0, 0, 1648, - 1649, 3, 94, 47, 0, 1649, 1650, 5, 410, 0, 0, 1650, 1651, 3, 94, 47, 0, - 1651, 1691, 1, 0, 0, 0, 1652, 1653, 5, 22, 0, 0, 1653, 1654, 5, 38, 0, - 0, 1654, 1655, 3, 94, 47, 0, 1655, 1659, 3, 98, 49, 0, 1656, 1658, 3, 96, - 48, 0, 1657, 1656, 1, 0, 0, 0, 1658, 1661, 1, 0, 0, 0, 1659, 1657, 1, 0, - 0, 0, 1659, 1660, 1, 0, 0, 0, 1660, 1691, 1, 0, 0, 0, 1661, 1659, 1, 0, - 0, 0, 1662, 1663, 5, 22, 0, 0, 1663, 1664, 5, 39, 0, 0, 1664, 1665, 3, - 94, 47, 0, 1665, 1669, 3, 98, 49, 0, 1666, 1668, 3, 96, 48, 0, 1667, 1666, - 1, 0, 0, 0, 1668, 1671, 1, 0, 0, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1670, - 1, 0, 0, 0, 1670, 1691, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1673, - 5, 19, 0, 0, 1673, 1674, 5, 38, 0, 0, 1674, 1691, 3, 94, 47, 0, 1675, 1676, - 5, 19, 0, 0, 1676, 1677, 5, 39, 0, 0, 1677, 1691, 3, 94, 47, 0, 1678, 1679, - 5, 47, 0, 0, 1679, 1680, 5, 49, 0, 0, 1680, 1691, 5, 478, 0, 0, 1681, 1682, - 5, 47, 0, 0, 1682, 1683, 5, 393, 0, 0, 1683, 1691, 5, 478, 0, 0, 1684, - 1685, 5, 46, 0, 0, 1685, 1686, 5, 41, 0, 0, 1686, 1691, 3, 104, 52, 0, - 1687, 1688, 5, 19, 0, 0, 1688, 1689, 5, 41, 0, 0, 1689, 1691, 5, 482, 0, - 0, 1690, 1634, 1, 0, 0, 0, 1690, 1637, 1, 0, 0, 0, 1690, 1640, 1, 0, 0, - 0, 1690, 1646, 1, 0, 0, 0, 1690, 1652, 1, 0, 0, 0, 1690, 1662, 1, 0, 0, - 0, 1690, 1672, 1, 0, 0, 0, 1690, 1675, 1, 0, 0, 0, 1690, 1678, 1, 0, 0, - 0, 1690, 1681, 1, 0, 0, 0, 1690, 1684, 1, 0, 0, 0, 1690, 1687, 1, 0, 0, - 0, 1691, 121, 1, 0, 0, 0, 1692, 1693, 5, 47, 0, 0, 1693, 1694, 5, 52, 0, - 0, 1694, 1705, 3, 118, 59, 0, 1695, 1696, 5, 47, 0, 0, 1696, 1697, 5, 42, - 0, 0, 1697, 1705, 7, 8, 0, 0, 1698, 1699, 5, 47, 0, 0, 1699, 1700, 5, 50, - 0, 0, 1700, 1705, 7, 9, 0, 0, 1701, 1702, 5, 47, 0, 0, 1702, 1703, 5, 393, - 0, 0, 1703, 1705, 5, 478, 0, 0, 1704, 1692, 1, 0, 0, 0, 1704, 1695, 1, - 0, 0, 0, 1704, 1698, 1, 0, 0, 0, 1704, 1701, 1, 0, 0, 0, 1705, 123, 1, - 0, 0, 0, 1706, 1707, 5, 46, 0, 0, 1707, 1708, 5, 405, 0, 0, 1708, 1711, - 5, 482, 0, 0, 1709, 1710, 5, 186, 0, 0, 1710, 1712, 5, 478, 0, 0, 1711, - 1709, 1, 0, 0, 0, 1711, 1712, 1, 0, 0, 0, 1712, 1725, 1, 0, 0, 0, 1713, - 1714, 5, 20, 0, 0, 1714, 1715, 5, 405, 0, 0, 1715, 1716, 5, 482, 0, 0, - 1716, 1717, 5, 410, 0, 0, 1717, 1725, 5, 482, 0, 0, 1718, 1719, 5, 19, - 0, 0, 1719, 1720, 5, 405, 0, 0, 1720, 1725, 5, 482, 0, 0, 1721, 1722, 5, - 47, 0, 0, 1722, 1723, 5, 393, 0, 0, 1723, 1725, 5, 478, 0, 0, 1724, 1706, - 1, 0, 0, 0, 1724, 1713, 1, 0, 0, 0, 1724, 1718, 1, 0, 0, 0, 1724, 1721, - 1, 0, 0, 0, 1725, 125, 1, 0, 0, 0, 1726, 1727, 5, 46, 0, 0, 1727, 1728, - 5, 33, 0, 0, 1728, 1731, 3, 646, 323, 0, 1729, 1730, 5, 48, 0, 0, 1730, - 1732, 5, 480, 0, 0, 1731, 1729, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, - 1740, 1, 0, 0, 0, 1733, 1734, 5, 19, 0, 0, 1734, 1735, 5, 33, 0, 0, 1735, - 1740, 3, 646, 323, 0, 1736, 1737, 5, 47, 0, 0, 1737, 1738, 5, 393, 0, 0, - 1738, 1740, 5, 478, 0, 0, 1739, 1726, 1, 0, 0, 0, 1739, 1733, 1, 0, 0, - 0, 1739, 1736, 1, 0, 0, 0, 1740, 127, 1, 0, 0, 0, 1741, 1742, 5, 29, 0, - 0, 1742, 1744, 5, 482, 0, 0, 1743, 1745, 3, 130, 65, 0, 1744, 1743, 1, - 0, 0, 0, 1744, 1745, 1, 0, 0, 0, 1745, 129, 1, 0, 0, 0, 1746, 1748, 3, - 132, 66, 0, 1747, 1746, 1, 0, 0, 0, 1748, 1749, 1, 0, 0, 0, 1749, 1747, - 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 131, 1, 0, 0, 0, 1751, 1752, - 5, 393, 0, 0, 1752, 1756, 5, 478, 0, 0, 1753, 1754, 5, 215, 0, 0, 1754, - 1756, 5, 478, 0, 0, 1755, 1751, 1, 0, 0, 0, 1755, 1753, 1, 0, 0, 0, 1756, - 133, 1, 0, 0, 0, 1757, 1758, 5, 28, 0, 0, 1758, 1759, 3, 646, 323, 0, 1759, - 1760, 5, 464, 0, 0, 1760, 1761, 3, 136, 68, 0, 1761, 1763, 5, 465, 0, 0, - 1762, 1764, 3, 142, 71, 0, 1763, 1762, 1, 0, 0, 0, 1763, 1764, 1, 0, 0, - 0, 1764, 135, 1, 0, 0, 0, 1765, 1770, 3, 138, 69, 0, 1766, 1767, 5, 462, - 0, 0, 1767, 1769, 3, 138, 69, 0, 1768, 1766, 1, 0, 0, 0, 1769, 1772, 1, - 0, 0, 0, 1770, 1768, 1, 0, 0, 0, 1770, 1771, 1, 0, 0, 0, 1771, 137, 1, - 0, 0, 0, 1772, 1770, 1, 0, 0, 0, 1773, 1775, 3, 656, 328, 0, 1774, 1773, - 1, 0, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1781, - 3, 140, 70, 0, 1777, 1779, 5, 186, 0, 0, 1778, 1777, 1, 0, 0, 0, 1778, - 1779, 1, 0, 0, 0, 1779, 1780, 1, 0, 0, 0, 1780, 1782, 5, 478, 0, 0, 1781, - 1778, 1, 0, 0, 0, 1781, 1782, 1, 0, 0, 0, 1782, 139, 1, 0, 0, 0, 1783, - 1799, 5, 482, 0, 0, 1784, 1799, 5, 484, 0, 0, 1785, 1799, 3, 668, 334, - 0, 1786, 1799, 5, 306, 0, 0, 1787, 1799, 5, 307, 0, 0, 1788, 1799, 5, 337, - 0, 0, 1789, 1799, 5, 336, 0, 0, 1790, 1799, 5, 312, 0, 0, 1791, 1799, 5, - 331, 0, 0, 1792, 1799, 5, 332, 0, 0, 1793, 1799, 5, 333, 0, 0, 1794, 1799, - 5, 334, 0, 0, 1795, 1799, 5, 26, 0, 0, 1796, 1799, 5, 338, 0, 0, 1797, - 1799, 5, 360, 0, 0, 1798, 1783, 1, 0, 0, 0, 1798, 1784, 1, 0, 0, 0, 1798, - 1785, 1, 0, 0, 0, 1798, 1786, 1, 0, 0, 0, 1798, 1787, 1, 0, 0, 0, 1798, - 1788, 1, 0, 0, 0, 1798, 1789, 1, 0, 0, 0, 1798, 1790, 1, 0, 0, 0, 1798, - 1791, 1, 0, 0, 0, 1798, 1792, 1, 0, 0, 0, 1798, 1793, 1, 0, 0, 0, 1798, - 1794, 1, 0, 0, 0, 1798, 1795, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1798, - 1797, 1, 0, 0, 0, 1799, 141, 1, 0, 0, 0, 1800, 1802, 3, 144, 72, 0, 1801, - 1800, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1801, 1, 0, 0, 0, 1803, - 1804, 1, 0, 0, 0, 1804, 143, 1, 0, 0, 0, 1805, 1806, 5, 393, 0, 0, 1806, - 1807, 5, 478, 0, 0, 1807, 145, 1, 0, 0, 0, 1808, 1809, 5, 293, 0, 0, 1809, - 1810, 5, 295, 0, 0, 1810, 1811, 3, 646, 323, 0, 1811, 1812, 5, 413, 0, - 0, 1812, 1813, 3, 646, 323, 0, 1813, 1814, 3, 148, 74, 0, 1814, 147, 1, - 0, 0, 0, 1815, 1816, 5, 302, 0, 0, 1816, 1817, 3, 608, 304, 0, 1817, 1818, - 5, 294, 0, 0, 1818, 1819, 5, 478, 0, 0, 1819, 1843, 1, 0, 0, 0, 1820, 1821, - 5, 296, 0, 0, 1821, 1822, 3, 152, 76, 0, 1822, 1823, 5, 294, 0, 0, 1823, - 1824, 5, 478, 0, 0, 1824, 1843, 1, 0, 0, 0, 1825, 1826, 5, 289, 0, 0, 1826, - 1827, 3, 154, 77, 0, 1827, 1828, 5, 294, 0, 0, 1828, 1829, 5, 478, 0, 0, - 1829, 1843, 1, 0, 0, 0, 1830, 1831, 5, 299, 0, 0, 1831, 1832, 3, 152, 76, - 0, 1832, 1833, 3, 150, 75, 0, 1833, 1834, 5, 294, 0, 0, 1834, 1835, 5, - 478, 0, 0, 1835, 1843, 1, 0, 0, 0, 1836, 1837, 5, 300, 0, 0, 1837, 1838, - 3, 152, 76, 0, 1838, 1839, 5, 478, 0, 0, 1839, 1840, 5, 294, 0, 0, 1840, - 1841, 5, 478, 0, 0, 1841, 1843, 1, 0, 0, 0, 1842, 1815, 1, 0, 0, 0, 1842, - 1820, 1, 0, 0, 0, 1842, 1825, 1, 0, 0, 0, 1842, 1830, 1, 0, 0, 0, 1842, - 1836, 1, 0, 0, 0, 1843, 149, 1, 0, 0, 0, 1844, 1845, 5, 285, 0, 0, 1845, - 1846, 3, 650, 325, 0, 1846, 1847, 5, 280, 0, 0, 1847, 1848, 3, 650, 325, - 0, 1848, 1858, 1, 0, 0, 0, 1849, 1850, 5, 452, 0, 0, 1850, 1858, 3, 650, - 325, 0, 1851, 1852, 5, 449, 0, 0, 1852, 1858, 3, 650, 325, 0, 1853, 1854, - 5, 453, 0, 0, 1854, 1858, 3, 650, 325, 0, 1855, 1856, 5, 450, 0, 0, 1856, - 1858, 3, 650, 325, 0, 1857, 1844, 1, 0, 0, 0, 1857, 1849, 1, 0, 0, 0, 1857, - 1851, 1, 0, 0, 0, 1857, 1853, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1858, - 151, 1, 0, 0, 0, 1859, 1864, 5, 482, 0, 0, 1860, 1861, 5, 457, 0, 0, 1861, - 1863, 5, 482, 0, 0, 1862, 1860, 1, 0, 0, 0, 1863, 1866, 1, 0, 0, 0, 1864, - 1862, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 153, 1, 0, 0, 0, 1866, - 1864, 1, 0, 0, 0, 1867, 1872, 3, 152, 76, 0, 1868, 1869, 5, 462, 0, 0, - 1869, 1871, 3, 152, 76, 0, 1870, 1868, 1, 0, 0, 0, 1871, 1874, 1, 0, 0, - 0, 1872, 1870, 1, 0, 0, 0, 1872, 1873, 1, 0, 0, 0, 1873, 155, 1, 0, 0, - 0, 1874, 1872, 1, 0, 0, 0, 1875, 1876, 5, 30, 0, 0, 1876, 1877, 3, 646, - 323, 0, 1877, 1879, 5, 464, 0, 0, 1878, 1880, 3, 168, 84, 0, 1879, 1878, - 1, 0, 0, 0, 1879, 1880, 1, 0, 0, 0, 1880, 1881, 1, 0, 0, 0, 1881, 1883, - 5, 465, 0, 0, 1882, 1884, 3, 174, 87, 0, 1883, 1882, 1, 0, 0, 0, 1883, - 1884, 1, 0, 0, 0, 1884, 1886, 1, 0, 0, 0, 1885, 1887, 3, 176, 88, 0, 1886, - 1885, 1, 0, 0, 0, 1886, 1887, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, - 1889, 5, 95, 0, 0, 1889, 1890, 3, 180, 90, 0, 1890, 1892, 5, 82, 0, 0, - 1891, 1893, 5, 461, 0, 0, 1892, 1891, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, - 0, 1893, 1895, 1, 0, 0, 0, 1894, 1896, 5, 457, 0, 0, 1895, 1894, 1, 0, - 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 157, 1, 0, 0, 0, 1897, 1898, 5, 113, - 0, 0, 1898, 1899, 5, 114, 0, 0, 1899, 1900, 3, 646, 323, 0, 1900, 1902, - 5, 464, 0, 0, 1901, 1903, 3, 160, 80, 0, 1902, 1901, 1, 0, 0, 0, 1902, - 1903, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 1906, 5, 465, 0, 0, 1905, - 1907, 3, 164, 82, 0, 1906, 1905, 1, 0, 0, 0, 1906, 1907, 1, 0, 0, 0, 1907, - 1909, 1, 0, 0, 0, 1908, 1910, 3, 166, 83, 0, 1909, 1908, 1, 0, 0, 0, 1909, - 1910, 1, 0, 0, 0, 1910, 1911, 1, 0, 0, 0, 1911, 1912, 5, 75, 0, 0, 1912, - 1914, 5, 479, 0, 0, 1913, 1915, 5, 461, 0, 0, 1914, 1913, 1, 0, 0, 0, 1914, - 1915, 1, 0, 0, 0, 1915, 159, 1, 0, 0, 0, 1916, 1921, 3, 162, 81, 0, 1917, - 1918, 5, 462, 0, 0, 1918, 1920, 3, 162, 81, 0, 1919, 1917, 1, 0, 0, 0, - 1920, 1923, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1921, 1922, 1, 0, 0, 0, - 1922, 161, 1, 0, 0, 0, 1923, 1921, 1, 0, 0, 0, 1924, 1925, 3, 172, 86, - 0, 1925, 1926, 5, 470, 0, 0, 1926, 1928, 3, 98, 49, 0, 1927, 1929, 5, 7, - 0, 0, 1928, 1927, 1, 0, 0, 0, 1928, 1929, 1, 0, 0, 0, 1929, 163, 1, 0, - 0, 0, 1930, 1931, 5, 76, 0, 0, 1931, 1932, 3, 98, 49, 0, 1932, 165, 1, - 0, 0, 0, 1933, 1934, 5, 357, 0, 0, 1934, 1935, 5, 75, 0, 0, 1935, 1936, - 5, 478, 0, 0, 1936, 1937, 5, 284, 0, 0, 1937, 1938, 5, 478, 0, 0, 1938, - 167, 1, 0, 0, 0, 1939, 1944, 3, 170, 85, 0, 1940, 1941, 5, 462, 0, 0, 1941, - 1943, 3, 170, 85, 0, 1942, 1940, 1, 0, 0, 0, 1943, 1946, 1, 0, 0, 0, 1944, - 1942, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 169, 1, 0, 0, 0, 1946, - 1944, 1, 0, 0, 0, 1947, 1950, 3, 172, 86, 0, 1948, 1950, 5, 481, 0, 0, - 1949, 1947, 1, 0, 0, 0, 1949, 1948, 1, 0, 0, 0, 1950, 1951, 1, 0, 0, 0, - 1951, 1952, 5, 470, 0, 0, 1952, 1953, 3, 98, 49, 0, 1953, 171, 1, 0, 0, - 0, 1954, 1958, 5, 482, 0, 0, 1955, 1958, 5, 484, 0, 0, 1956, 1958, 3, 668, - 334, 0, 1957, 1954, 1, 0, 0, 0, 1957, 1955, 1, 0, 0, 0, 1957, 1956, 1, - 0, 0, 0, 1958, 173, 1, 0, 0, 0, 1959, 1960, 5, 76, 0, 0, 1960, 1963, 3, - 98, 49, 0, 1961, 1962, 5, 75, 0, 0, 1962, 1964, 5, 481, 0, 0, 1963, 1961, - 1, 0, 0, 0, 1963, 1964, 1, 0, 0, 0, 1964, 175, 1, 0, 0, 0, 1965, 1967, - 3, 178, 89, 0, 1966, 1965, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 1966, - 1, 0, 0, 0, 1968, 1969, 1, 0, 0, 0, 1969, 177, 1, 0, 0, 0, 1970, 1971, - 5, 215, 0, 0, 1971, 1975, 5, 478, 0, 0, 1972, 1973, 5, 393, 0, 0, 1973, - 1975, 5, 478, 0, 0, 1974, 1970, 1, 0, 0, 0, 1974, 1972, 1, 0, 0, 0, 1975, - 179, 1, 0, 0, 0, 1976, 1978, 3, 182, 91, 0, 1977, 1976, 1, 0, 0, 0, 1978, - 1981, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, - 181, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1982, 1984, 3, 658, 329, 0, 1983, - 1982, 1, 0, 0, 0, 1984, 1987, 1, 0, 0, 0, 1985, 1983, 1, 0, 0, 0, 1985, - 1986, 1, 0, 0, 0, 1986, 1988, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, 0, 1988, - 1990, 3, 184, 92, 0, 1989, 1991, 5, 461, 0, 0, 1990, 1989, 1, 0, 0, 0, - 1990, 1991, 1, 0, 0, 0, 1991, 2303, 1, 0, 0, 0, 1992, 1994, 3, 658, 329, - 0, 1993, 1992, 1, 0, 0, 0, 1994, 1997, 1, 0, 0, 0, 1995, 1993, 1, 0, 0, - 0, 1995, 1996, 1, 0, 0, 0, 1996, 1998, 1, 0, 0, 0, 1997, 1995, 1, 0, 0, - 0, 1998, 2000, 3, 186, 93, 0, 1999, 2001, 5, 461, 0, 0, 2000, 1999, 1, - 0, 0, 0, 2000, 2001, 1, 0, 0, 0, 2001, 2303, 1, 0, 0, 0, 2002, 2004, 3, - 658, 329, 0, 2003, 2002, 1, 0, 0, 0, 2004, 2007, 1, 0, 0, 0, 2005, 2003, - 1, 0, 0, 0, 2005, 2006, 1, 0, 0, 0, 2006, 2008, 1, 0, 0, 0, 2007, 2005, - 1, 0, 0, 0, 2008, 2010, 3, 290, 145, 0, 2009, 2011, 5, 461, 0, 0, 2010, - 2009, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2303, 1, 0, 0, 0, 2012, - 2014, 3, 658, 329, 0, 2013, 2012, 1, 0, 0, 0, 2014, 2017, 1, 0, 0, 0, 2015, - 2013, 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 2018, 1, 0, 0, 0, 2017, - 2015, 1, 0, 0, 0, 2018, 2020, 3, 188, 94, 0, 2019, 2021, 5, 461, 0, 0, - 2020, 2019, 1, 0, 0, 0, 2020, 2021, 1, 0, 0, 0, 2021, 2303, 1, 0, 0, 0, - 2022, 2024, 3, 658, 329, 0, 2023, 2022, 1, 0, 0, 0, 2024, 2027, 1, 0, 0, - 0, 2025, 2023, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2028, 1, 0, 0, - 0, 2027, 2025, 1, 0, 0, 0, 2028, 2030, 3, 190, 95, 0, 2029, 2031, 5, 461, - 0, 0, 2030, 2029, 1, 0, 0, 0, 2030, 2031, 1, 0, 0, 0, 2031, 2303, 1, 0, - 0, 0, 2032, 2034, 3, 658, 329, 0, 2033, 2032, 1, 0, 0, 0, 2034, 2037, 1, - 0, 0, 0, 2035, 2033, 1, 0, 0, 0, 2035, 2036, 1, 0, 0, 0, 2036, 2038, 1, - 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2038, 2040, 3, 194, 97, 0, 2039, 2041, - 5, 461, 0, 0, 2040, 2039, 1, 0, 0, 0, 2040, 2041, 1, 0, 0, 0, 2041, 2303, - 1, 0, 0, 0, 2042, 2044, 3, 658, 329, 0, 2043, 2042, 1, 0, 0, 0, 2044, 2047, - 1, 0, 0, 0, 2045, 2043, 1, 0, 0, 0, 2045, 2046, 1, 0, 0, 0, 2046, 2048, - 1, 0, 0, 0, 2047, 2045, 1, 0, 0, 0, 2048, 2050, 3, 196, 98, 0, 2049, 2051, - 5, 461, 0, 0, 2050, 2049, 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, 2303, - 1, 0, 0, 0, 2052, 2054, 3, 658, 329, 0, 2053, 2052, 1, 0, 0, 0, 2054, 2057, - 1, 0, 0, 0, 2055, 2053, 1, 0, 0, 0, 2055, 2056, 1, 0, 0, 0, 2056, 2058, - 1, 0, 0, 0, 2057, 2055, 1, 0, 0, 0, 2058, 2060, 3, 198, 99, 0, 2059, 2061, - 5, 461, 0, 0, 2060, 2059, 1, 0, 0, 0, 2060, 2061, 1, 0, 0, 0, 2061, 2303, - 1, 0, 0, 0, 2062, 2064, 3, 658, 329, 0, 2063, 2062, 1, 0, 0, 0, 2064, 2067, - 1, 0, 0, 0, 2065, 2063, 1, 0, 0, 0, 2065, 2066, 1, 0, 0, 0, 2066, 2068, - 1, 0, 0, 0, 2067, 2065, 1, 0, 0, 0, 2068, 2070, 3, 200, 100, 0, 2069, 2071, - 5, 461, 0, 0, 2070, 2069, 1, 0, 0, 0, 2070, 2071, 1, 0, 0, 0, 2071, 2303, - 1, 0, 0, 0, 2072, 2074, 3, 658, 329, 0, 2073, 2072, 1, 0, 0, 0, 2074, 2077, - 1, 0, 0, 0, 2075, 2073, 1, 0, 0, 0, 2075, 2076, 1, 0, 0, 0, 2076, 2078, - 1, 0, 0, 0, 2077, 2075, 1, 0, 0, 0, 2078, 2080, 3, 206, 103, 0, 2079, 2081, - 5, 461, 0, 0, 2080, 2079, 1, 0, 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2303, - 1, 0, 0, 0, 2082, 2084, 3, 658, 329, 0, 2083, 2082, 1, 0, 0, 0, 2084, 2087, - 1, 0, 0, 0, 2085, 2083, 1, 0, 0, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2088, - 1, 0, 0, 0, 2087, 2085, 1, 0, 0, 0, 2088, 2090, 3, 208, 104, 0, 2089, 2091, - 5, 461, 0, 0, 2090, 2089, 1, 0, 0, 0, 2090, 2091, 1, 0, 0, 0, 2091, 2303, - 1, 0, 0, 0, 2092, 2094, 3, 658, 329, 0, 2093, 2092, 1, 0, 0, 0, 2094, 2097, - 1, 0, 0, 0, 2095, 2093, 1, 0, 0, 0, 2095, 2096, 1, 0, 0, 0, 2096, 2098, - 1, 0, 0, 0, 2097, 2095, 1, 0, 0, 0, 2098, 2100, 3, 210, 105, 0, 2099, 2101, - 5, 461, 0, 0, 2100, 2099, 1, 0, 0, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2303, - 1, 0, 0, 0, 2102, 2104, 3, 658, 329, 0, 2103, 2102, 1, 0, 0, 0, 2104, 2107, - 1, 0, 0, 0, 2105, 2103, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2108, - 1, 0, 0, 0, 2107, 2105, 1, 0, 0, 0, 2108, 2110, 3, 212, 106, 0, 2109, 2111, - 5, 461, 0, 0, 2110, 2109, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2303, - 1, 0, 0, 0, 2112, 2114, 3, 658, 329, 0, 2113, 2112, 1, 0, 0, 0, 2114, 2117, - 1, 0, 0, 0, 2115, 2113, 1, 0, 0, 0, 2115, 2116, 1, 0, 0, 0, 2116, 2118, - 1, 0, 0, 0, 2117, 2115, 1, 0, 0, 0, 2118, 2120, 3, 214, 107, 0, 2119, 2121, - 5, 461, 0, 0, 2120, 2119, 1, 0, 0, 0, 2120, 2121, 1, 0, 0, 0, 2121, 2303, - 1, 0, 0, 0, 2122, 2124, 3, 658, 329, 0, 2123, 2122, 1, 0, 0, 0, 2124, 2127, - 1, 0, 0, 0, 2125, 2123, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2128, - 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2128, 2130, 3, 216, 108, 0, 2129, 2131, - 5, 461, 0, 0, 2130, 2129, 1, 0, 0, 0, 2130, 2131, 1, 0, 0, 0, 2131, 2303, - 1, 0, 0, 0, 2132, 2134, 3, 658, 329, 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, 2140, 3, 218, 109, 0, 2139, 2141, - 5, 461, 0, 0, 2140, 2139, 1, 0, 0, 0, 2140, 2141, 1, 0, 0, 0, 2141, 2303, - 1, 0, 0, 0, 2142, 2144, 3, 658, 329, 0, 2143, 2142, 1, 0, 0, 0, 2144, 2147, - 1, 0, 0, 0, 2145, 2143, 1, 0, 0, 0, 2145, 2146, 1, 0, 0, 0, 2146, 2148, - 1, 0, 0, 0, 2147, 2145, 1, 0, 0, 0, 2148, 2150, 3, 220, 110, 0, 2149, 2151, - 5, 461, 0, 0, 2150, 2149, 1, 0, 0, 0, 2150, 2151, 1, 0, 0, 0, 2151, 2303, - 1, 0, 0, 0, 2152, 2154, 3, 658, 329, 0, 2153, 2152, 1, 0, 0, 0, 2154, 2157, - 1, 0, 0, 0, 2155, 2153, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2158, - 1, 0, 0, 0, 2157, 2155, 1, 0, 0, 0, 2158, 2160, 3, 232, 116, 0, 2159, 2161, - 5, 461, 0, 0, 2160, 2159, 1, 0, 0, 0, 2160, 2161, 1, 0, 0, 0, 2161, 2303, - 1, 0, 0, 0, 2162, 2164, 3, 658, 329, 0, 2163, 2162, 1, 0, 0, 0, 2164, 2167, - 1, 0, 0, 0, 2165, 2163, 1, 0, 0, 0, 2165, 2166, 1, 0, 0, 0, 2166, 2168, - 1, 0, 0, 0, 2167, 2165, 1, 0, 0, 0, 2168, 2170, 3, 234, 117, 0, 2169, 2171, - 5, 461, 0, 0, 2170, 2169, 1, 0, 0, 0, 2170, 2171, 1, 0, 0, 0, 2171, 2303, - 1, 0, 0, 0, 2172, 2174, 3, 658, 329, 0, 2173, 2172, 1, 0, 0, 0, 2174, 2177, - 1, 0, 0, 0, 2175, 2173, 1, 0, 0, 0, 2175, 2176, 1, 0, 0, 0, 2176, 2178, - 1, 0, 0, 0, 2177, 2175, 1, 0, 0, 0, 2178, 2180, 3, 236, 118, 0, 2179, 2181, - 5, 461, 0, 0, 2180, 2179, 1, 0, 0, 0, 2180, 2181, 1, 0, 0, 0, 2181, 2303, - 1, 0, 0, 0, 2182, 2184, 3, 658, 329, 0, 2183, 2182, 1, 0, 0, 0, 2184, 2187, - 1, 0, 0, 0, 2185, 2183, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2188, - 1, 0, 0, 0, 2187, 2185, 1, 0, 0, 0, 2188, 2190, 3, 238, 119, 0, 2189, 2191, - 5, 461, 0, 0, 2190, 2189, 1, 0, 0, 0, 2190, 2191, 1, 0, 0, 0, 2191, 2303, - 1, 0, 0, 0, 2192, 2194, 3, 658, 329, 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, 2200, 3, 244, 122, 0, 2199, 2201, - 5, 461, 0, 0, 2200, 2199, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2303, - 1, 0, 0, 0, 2202, 2204, 3, 658, 329, 0, 2203, 2202, 1, 0, 0, 0, 2204, 2207, - 1, 0, 0, 0, 2205, 2203, 1, 0, 0, 0, 2205, 2206, 1, 0, 0, 0, 2206, 2208, - 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2210, 3, 250, 125, 0, 2209, 2211, - 5, 461, 0, 0, 2210, 2209, 1, 0, 0, 0, 2210, 2211, 1, 0, 0, 0, 2211, 2303, - 1, 0, 0, 0, 2212, 2214, 3, 658, 329, 0, 2213, 2212, 1, 0, 0, 0, 2214, 2217, - 1, 0, 0, 0, 2215, 2213, 1, 0, 0, 0, 2215, 2216, 1, 0, 0, 0, 2216, 2218, - 1, 0, 0, 0, 2217, 2215, 1, 0, 0, 0, 2218, 2220, 3, 252, 126, 0, 2219, 2221, - 5, 461, 0, 0, 2220, 2219, 1, 0, 0, 0, 2220, 2221, 1, 0, 0, 0, 2221, 2303, - 1, 0, 0, 0, 2222, 2224, 3, 658, 329, 0, 2223, 2222, 1, 0, 0, 0, 2224, 2227, - 1, 0, 0, 0, 2225, 2223, 1, 0, 0, 0, 2225, 2226, 1, 0, 0, 0, 2226, 2228, - 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2228, 2230, 3, 254, 127, 0, 2229, 2231, - 5, 461, 0, 0, 2230, 2229, 1, 0, 0, 0, 2230, 2231, 1, 0, 0, 0, 2231, 2303, - 1, 0, 0, 0, 2232, 2234, 3, 658, 329, 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, 256, 128, 0, 2239, 2241, - 5, 461, 0, 0, 2240, 2239, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 2303, - 1, 0, 0, 0, 2242, 2244, 3, 658, 329, 0, 2243, 2242, 1, 0, 0, 0, 2244, 2247, - 1, 0, 0, 0, 2245, 2243, 1, 0, 0, 0, 2245, 2246, 1, 0, 0, 0, 2246, 2248, - 1, 0, 0, 0, 2247, 2245, 1, 0, 0, 0, 2248, 2250, 3, 278, 139, 0, 2249, 2251, - 5, 461, 0, 0, 2250, 2249, 1, 0, 0, 0, 2250, 2251, 1, 0, 0, 0, 2251, 2303, - 1, 0, 0, 0, 2252, 2254, 3, 658, 329, 0, 2253, 2252, 1, 0, 0, 0, 2254, 2257, - 1, 0, 0, 0, 2255, 2253, 1, 0, 0, 0, 2255, 2256, 1, 0, 0, 0, 2256, 2258, - 1, 0, 0, 0, 2257, 2255, 1, 0, 0, 0, 2258, 2260, 3, 286, 143, 0, 2259, 2261, - 5, 461, 0, 0, 2260, 2259, 1, 0, 0, 0, 2260, 2261, 1, 0, 0, 0, 2261, 2303, - 1, 0, 0, 0, 2262, 2264, 3, 658, 329, 0, 2263, 2262, 1, 0, 0, 0, 2264, 2267, - 1, 0, 0, 0, 2265, 2263, 1, 0, 0, 0, 2265, 2266, 1, 0, 0, 0, 2266, 2268, - 1, 0, 0, 0, 2267, 2265, 1, 0, 0, 0, 2268, 2270, 3, 292, 146, 0, 2269, 2271, - 5, 461, 0, 0, 2270, 2269, 1, 0, 0, 0, 2270, 2271, 1, 0, 0, 0, 2271, 2303, - 1, 0, 0, 0, 2272, 2274, 3, 658, 329, 0, 2273, 2272, 1, 0, 0, 0, 2274, 2277, - 1, 0, 0, 0, 2275, 2273, 1, 0, 0, 0, 2275, 2276, 1, 0, 0, 0, 2276, 2278, - 1, 0, 0, 0, 2277, 2275, 1, 0, 0, 0, 2278, 2280, 3, 294, 147, 0, 2279, 2281, - 5, 461, 0, 0, 2280, 2279, 1, 0, 0, 0, 2280, 2281, 1, 0, 0, 0, 2281, 2303, - 1, 0, 0, 0, 2282, 2284, 3, 658, 329, 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, 2290, 3, 258, 129, 0, 2289, 2291, - 5, 461, 0, 0, 2290, 2289, 1, 0, 0, 0, 2290, 2291, 1, 0, 0, 0, 2291, 2303, - 1, 0, 0, 0, 2292, 2294, 3, 658, 329, 0, 2293, 2292, 1, 0, 0, 0, 2294, 2297, - 1, 0, 0, 0, 2295, 2293, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2298, - 1, 0, 0, 0, 2297, 2295, 1, 0, 0, 0, 2298, 2300, 3, 260, 130, 0, 2299, 2301, - 5, 461, 0, 0, 2300, 2299, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2301, 2303, - 1, 0, 0, 0, 2302, 1985, 1, 0, 0, 0, 2302, 1995, 1, 0, 0, 0, 2302, 2005, - 1, 0, 0, 0, 2302, 2015, 1, 0, 0, 0, 2302, 2025, 1, 0, 0, 0, 2302, 2035, - 1, 0, 0, 0, 2302, 2045, 1, 0, 0, 0, 2302, 2055, 1, 0, 0, 0, 2302, 2065, - 1, 0, 0, 0, 2302, 2075, 1, 0, 0, 0, 2302, 2085, 1, 0, 0, 0, 2302, 2095, - 1, 0, 0, 0, 2302, 2105, 1, 0, 0, 0, 2302, 2115, 1, 0, 0, 0, 2302, 2125, - 1, 0, 0, 0, 2302, 2135, 1, 0, 0, 0, 2302, 2145, 1, 0, 0, 0, 2302, 2155, - 1, 0, 0, 0, 2302, 2165, 1, 0, 0, 0, 2302, 2175, 1, 0, 0, 0, 2302, 2185, - 1, 0, 0, 0, 2302, 2195, 1, 0, 0, 0, 2302, 2205, 1, 0, 0, 0, 2302, 2215, - 1, 0, 0, 0, 2302, 2225, 1, 0, 0, 0, 2302, 2235, 1, 0, 0, 0, 2302, 2245, - 1, 0, 0, 0, 2302, 2255, 1, 0, 0, 0, 2302, 2265, 1, 0, 0, 0, 2302, 2275, - 1, 0, 0, 0, 2302, 2285, 1, 0, 0, 0, 2302, 2295, 1, 0, 0, 0, 2303, 183, - 1, 0, 0, 0, 2304, 2305, 5, 96, 0, 0, 2305, 2306, 5, 481, 0, 0, 2306, 2309, - 3, 98, 49, 0, 2307, 2308, 5, 451, 0, 0, 2308, 2310, 3, 608, 304, 0, 2309, - 2307, 1, 0, 0, 0, 2309, 2310, 1, 0, 0, 0, 2310, 185, 1, 0, 0, 0, 2311, - 2314, 5, 47, 0, 0, 2312, 2315, 5, 481, 0, 0, 2313, 2315, 3, 192, 96, 0, - 2314, 2312, 1, 0, 0, 0, 2314, 2313, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, - 2316, 2317, 5, 451, 0, 0, 2317, 2318, 3, 608, 304, 0, 2318, 187, 1, 0, - 0, 0, 2319, 2320, 5, 481, 0, 0, 2320, 2322, 5, 451, 0, 0, 2321, 2319, 1, - 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2323, 1, 0, 0, 0, 2323, 2324, 5, - 17, 0, 0, 2324, 2330, 3, 102, 51, 0, 2325, 2327, 5, 464, 0, 0, 2326, 2328, - 3, 296, 148, 0, 2327, 2326, 1, 0, 0, 0, 2327, 2328, 1, 0, 0, 0, 2328, 2329, - 1, 0, 0, 0, 2329, 2331, 5, 465, 0, 0, 2330, 2325, 1, 0, 0, 0, 2330, 2331, - 1, 0, 0, 0, 2331, 2333, 1, 0, 0, 0, 2332, 2334, 3, 204, 102, 0, 2333, 2332, - 1, 0, 0, 0, 2333, 2334, 1, 0, 0, 0, 2334, 189, 1, 0, 0, 0, 2335, 2336, - 5, 97, 0, 0, 2336, 2342, 5, 481, 0, 0, 2337, 2339, 5, 464, 0, 0, 2338, - 2340, 3, 296, 148, 0, 2339, 2338, 1, 0, 0, 0, 2339, 2340, 1, 0, 0, 0, 2340, - 2341, 1, 0, 0, 0, 2341, 2343, 5, 465, 0, 0, 2342, 2337, 1, 0, 0, 0, 2342, - 2343, 1, 0, 0, 0, 2343, 191, 1, 0, 0, 0, 2344, 2350, 5, 481, 0, 0, 2345, - 2348, 7, 11, 0, 0, 2346, 2349, 5, 482, 0, 0, 2347, 2349, 3, 646, 323, 0, - 2348, 2346, 1, 0, 0, 0, 2348, 2347, 1, 0, 0, 0, 2349, 2351, 1, 0, 0, 0, - 2350, 2345, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, - 2352, 2353, 1, 0, 0, 0, 2353, 193, 1, 0, 0, 0, 2354, 2355, 5, 100, 0, 0, - 2355, 2358, 5, 481, 0, 0, 2356, 2357, 5, 137, 0, 0, 2357, 2359, 5, 118, - 0, 0, 2358, 2356, 1, 0, 0, 0, 2358, 2359, 1, 0, 0, 0, 2359, 2361, 1, 0, - 0, 0, 2360, 2362, 5, 383, 0, 0, 2361, 2360, 1, 0, 0, 0, 2361, 2362, 1, - 0, 0, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2365, 3, 204, 102, 0, 2364, 2363, - 1, 0, 0, 0, 2364, 2365, 1, 0, 0, 0, 2365, 195, 1, 0, 0, 0, 2366, 2367, - 5, 99, 0, 0, 2367, 2369, 5, 481, 0, 0, 2368, 2370, 3, 204, 102, 0, 2369, - 2368, 1, 0, 0, 0, 2369, 2370, 1, 0, 0, 0, 2370, 197, 1, 0, 0, 0, 2371, - 2372, 5, 101, 0, 0, 2372, 2374, 5, 481, 0, 0, 2373, 2375, 5, 383, 0, 0, - 2374, 2373, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 199, 1, 0, 0, 0, - 2376, 2377, 5, 98, 0, 0, 2377, 2378, 5, 481, 0, 0, 2378, 2379, 5, 70, 0, - 0, 2379, 2385, 3, 202, 101, 0, 2380, 2383, 5, 71, 0, 0, 2381, 2384, 3, - 328, 164, 0, 2382, 2384, 3, 608, 304, 0, 2383, 2381, 1, 0, 0, 0, 2383, - 2382, 1, 0, 0, 0, 2384, 2386, 1, 0, 0, 0, 2385, 2380, 1, 0, 0, 0, 2385, - 2386, 1, 0, 0, 0, 2386, 2396, 1, 0, 0, 0, 2387, 2388, 5, 10, 0, 0, 2388, - 2393, 3, 326, 163, 0, 2389, 2390, 5, 462, 0, 0, 2390, 2392, 3, 326, 163, - 0, 2391, 2389, 1, 0, 0, 0, 2392, 2395, 1, 0, 0, 0, 2393, 2391, 1, 0, 0, - 0, 2393, 2394, 1, 0, 0, 0, 2394, 2397, 1, 0, 0, 0, 2395, 2393, 1, 0, 0, - 0, 2396, 2387, 1, 0, 0, 0, 2396, 2397, 1, 0, 0, 0, 2397, 2400, 1, 0, 0, - 0, 2398, 2399, 5, 74, 0, 0, 2399, 2401, 3, 608, 304, 0, 2400, 2398, 1, - 0, 0, 0, 2400, 2401, 1, 0, 0, 0, 2401, 2404, 1, 0, 0, 0, 2402, 2403, 5, - 73, 0, 0, 2403, 2405, 3, 608, 304, 0, 2404, 2402, 1, 0, 0, 0, 2404, 2405, - 1, 0, 0, 0, 2405, 2407, 1, 0, 0, 0, 2406, 2408, 3, 204, 102, 0, 2407, 2406, - 1, 0, 0, 0, 2407, 2408, 1, 0, 0, 0, 2408, 201, 1, 0, 0, 0, 2409, 2417, - 3, 646, 323, 0, 2410, 2411, 5, 464, 0, 0, 2411, 2412, 3, 522, 261, 0, 2412, - 2413, 5, 465, 0, 0, 2413, 2417, 1, 0, 0, 0, 2414, 2415, 5, 343, 0, 0, 2415, - 2417, 5, 478, 0, 0, 2416, 2409, 1, 0, 0, 0, 2416, 2410, 1, 0, 0, 0, 2416, - 2414, 1, 0, 0, 0, 2417, 203, 1, 0, 0, 0, 2418, 2419, 5, 92, 0, 0, 2419, - 2420, 5, 297, 0, 0, 2420, 2439, 5, 107, 0, 0, 2421, 2422, 5, 92, 0, 0, - 2422, 2423, 5, 297, 0, 0, 2423, 2439, 5, 101, 0, 0, 2424, 2425, 5, 92, - 0, 0, 2425, 2426, 5, 297, 0, 0, 2426, 2427, 5, 466, 0, 0, 2427, 2428, 3, - 180, 90, 0, 2428, 2429, 5, 467, 0, 0, 2429, 2439, 1, 0, 0, 0, 2430, 2431, - 5, 92, 0, 0, 2431, 2432, 5, 297, 0, 0, 2432, 2433, 5, 419, 0, 0, 2433, - 2434, 5, 101, 0, 0, 2434, 2435, 5, 466, 0, 0, 2435, 2436, 3, 180, 90, 0, - 2436, 2437, 5, 467, 0, 0, 2437, 2439, 1, 0, 0, 0, 2438, 2418, 1, 0, 0, - 0, 2438, 2421, 1, 0, 0, 0, 2438, 2424, 1, 0, 0, 0, 2438, 2430, 1, 0, 0, - 0, 2439, 205, 1, 0, 0, 0, 2440, 2441, 5, 104, 0, 0, 2441, 2442, 3, 608, - 304, 0, 2442, 2443, 5, 80, 0, 0, 2443, 2451, 3, 180, 90, 0, 2444, 2445, - 5, 105, 0, 0, 2445, 2446, 3, 608, 304, 0, 2446, 2447, 5, 80, 0, 0, 2447, - 2448, 3, 180, 90, 0, 2448, 2450, 1, 0, 0, 0, 2449, 2444, 1, 0, 0, 0, 2450, - 2453, 1, 0, 0, 0, 2451, 2449, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, 0, 2452, - 2456, 1, 0, 0, 0, 2453, 2451, 1, 0, 0, 0, 2454, 2455, 5, 81, 0, 0, 2455, - 2457, 3, 180, 90, 0, 2456, 2454, 1, 0, 0, 0, 2456, 2457, 1, 0, 0, 0, 2457, - 2458, 1, 0, 0, 0, 2458, 2459, 5, 82, 0, 0, 2459, 2460, 5, 104, 0, 0, 2460, - 207, 1, 0, 0, 0, 2461, 2462, 5, 102, 0, 0, 2462, 2463, 5, 481, 0, 0, 2463, - 2466, 5, 284, 0, 0, 2464, 2467, 5, 481, 0, 0, 2465, 2467, 3, 192, 96, 0, - 2466, 2464, 1, 0, 0, 0, 2466, 2465, 1, 0, 0, 0, 2467, 2468, 1, 0, 0, 0, - 2468, 2469, 5, 95, 0, 0, 2469, 2470, 3, 180, 90, 0, 2470, 2471, 5, 82, - 0, 0, 2471, 2472, 5, 102, 0, 0, 2472, 209, 1, 0, 0, 0, 2473, 2474, 5, 103, - 0, 0, 2474, 2476, 3, 608, 304, 0, 2475, 2477, 5, 95, 0, 0, 2476, 2475, - 1, 0, 0, 0, 2476, 2477, 1, 0, 0, 0, 2477, 2478, 1, 0, 0, 0, 2478, 2479, - 3, 180, 90, 0, 2479, 2481, 5, 82, 0, 0, 2480, 2482, 5, 103, 0, 0, 2481, - 2480, 1, 0, 0, 0, 2481, 2482, 1, 0, 0, 0, 2482, 211, 1, 0, 0, 0, 2483, - 2484, 5, 107, 0, 0, 2484, 213, 1, 0, 0, 0, 2485, 2486, 5, 108, 0, 0, 2486, - 215, 1, 0, 0, 0, 2487, 2489, 5, 109, 0, 0, 2488, 2490, 3, 608, 304, 0, - 2489, 2488, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 217, 1, 0, 0, 0, - 2491, 2492, 5, 298, 0, 0, 2492, 2493, 5, 297, 0, 0, 2493, 219, 1, 0, 0, - 0, 2494, 2496, 5, 111, 0, 0, 2495, 2497, 3, 222, 111, 0, 2496, 2495, 1, - 0, 0, 0, 2496, 2497, 1, 0, 0, 0, 2497, 2500, 1, 0, 0, 0, 2498, 2499, 5, - 117, 0, 0, 2499, 2501, 5, 478, 0, 0, 2500, 2498, 1, 0, 0, 0, 2500, 2501, - 1, 0, 0, 0, 2501, 2502, 1, 0, 0, 0, 2502, 2504, 3, 608, 304, 0, 2503, 2505, - 3, 228, 114, 0, 2504, 2503, 1, 0, 0, 0, 2504, 2505, 1, 0, 0, 0, 2505, 221, - 1, 0, 0, 0, 2506, 2507, 7, 12, 0, 0, 2507, 223, 1, 0, 0, 0, 2508, 2509, - 5, 137, 0, 0, 2509, 2510, 5, 464, 0, 0, 2510, 2515, 3, 226, 113, 0, 2511, - 2512, 5, 462, 0, 0, 2512, 2514, 3, 226, 113, 0, 2513, 2511, 1, 0, 0, 0, - 2514, 2517, 1, 0, 0, 0, 2515, 2513, 1, 0, 0, 0, 2515, 2516, 1, 0, 0, 0, - 2516, 2518, 1, 0, 0, 0, 2517, 2515, 1, 0, 0, 0, 2518, 2519, 5, 465, 0, - 0, 2519, 2523, 1, 0, 0, 0, 2520, 2521, 5, 359, 0, 0, 2521, 2523, 3, 652, - 326, 0, 2522, 2508, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2523, 225, 1, 0, - 0, 0, 2524, 2525, 5, 466, 0, 0, 2525, 2526, 5, 480, 0, 0, 2526, 2527, 5, - 467, 0, 0, 2527, 2528, 5, 451, 0, 0, 2528, 2529, 3, 608, 304, 0, 2529, - 227, 1, 0, 0, 0, 2530, 2531, 3, 224, 112, 0, 2531, 229, 1, 0, 0, 0, 2532, - 2533, 3, 226, 113, 0, 2533, 231, 1, 0, 0, 0, 2534, 2535, 5, 481, 0, 0, - 2535, 2537, 5, 451, 0, 0, 2536, 2534, 1, 0, 0, 0, 2536, 2537, 1, 0, 0, - 0, 2537, 2538, 1, 0, 0, 0, 2538, 2539, 5, 112, 0, 0, 2539, 2540, 5, 30, - 0, 0, 2540, 2541, 3, 646, 323, 0, 2541, 2543, 5, 464, 0, 0, 2542, 2544, - 3, 240, 120, 0, 2543, 2542, 1, 0, 0, 0, 2543, 2544, 1, 0, 0, 0, 2544, 2545, - 1, 0, 0, 0, 2545, 2547, 5, 465, 0, 0, 2546, 2548, 3, 204, 102, 0, 2547, - 2546, 1, 0, 0, 0, 2547, 2548, 1, 0, 0, 0, 2548, 233, 1, 0, 0, 0, 2549, - 2550, 5, 481, 0, 0, 2550, 2552, 5, 451, 0, 0, 2551, 2549, 1, 0, 0, 0, 2551, - 2552, 1, 0, 0, 0, 2552, 2553, 1, 0, 0, 0, 2553, 2554, 5, 112, 0, 0, 2554, - 2555, 5, 113, 0, 0, 2555, 2556, 5, 114, 0, 0, 2556, 2557, 3, 646, 323, - 0, 2557, 2559, 5, 464, 0, 0, 2558, 2560, 3, 240, 120, 0, 2559, 2558, 1, - 0, 0, 0, 2559, 2560, 1, 0, 0, 0, 2560, 2561, 1, 0, 0, 0, 2561, 2563, 5, - 465, 0, 0, 2562, 2564, 3, 204, 102, 0, 2563, 2562, 1, 0, 0, 0, 2563, 2564, - 1, 0, 0, 0, 2564, 235, 1, 0, 0, 0, 2565, 2566, 5, 481, 0, 0, 2566, 2568, - 5, 451, 0, 0, 2567, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2569, - 1, 0, 0, 0, 2569, 2570, 5, 386, 0, 0, 2570, 2571, 5, 343, 0, 0, 2571, 2572, - 5, 344, 0, 0, 2572, 2579, 3, 646, 323, 0, 2573, 2577, 5, 164, 0, 0, 2574, - 2578, 5, 478, 0, 0, 2575, 2578, 5, 479, 0, 0, 2576, 2578, 3, 608, 304, - 0, 2577, 2574, 1, 0, 0, 0, 2577, 2575, 1, 0, 0, 0, 2577, 2576, 1, 0, 0, - 0, 2578, 2580, 1, 0, 0, 0, 2579, 2573, 1, 0, 0, 0, 2579, 2580, 1, 0, 0, - 0, 2580, 2586, 1, 0, 0, 0, 2581, 2583, 5, 464, 0, 0, 2582, 2584, 3, 240, - 120, 0, 2583, 2582, 1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, 2585, 1, - 0, 0, 0, 2585, 2587, 5, 465, 0, 0, 2586, 2581, 1, 0, 0, 0, 2586, 2587, - 1, 0, 0, 0, 2587, 2594, 1, 0, 0, 0, 2588, 2589, 5, 342, 0, 0, 2589, 2591, - 5, 464, 0, 0, 2590, 2592, 3, 240, 120, 0, 2591, 2590, 1, 0, 0, 0, 2591, - 2592, 1, 0, 0, 0, 2592, 2593, 1, 0, 0, 0, 2593, 2595, 5, 465, 0, 0, 2594, - 2588, 1, 0, 0, 0, 2594, 2595, 1, 0, 0, 0, 2595, 2597, 1, 0, 0, 0, 2596, - 2598, 3, 204, 102, 0, 2597, 2596, 1, 0, 0, 0, 2597, 2598, 1, 0, 0, 0, 2598, - 237, 1, 0, 0, 0, 2599, 2600, 5, 481, 0, 0, 2600, 2602, 5, 451, 0, 0, 2601, - 2599, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, - 2604, 5, 112, 0, 0, 2604, 2605, 5, 26, 0, 0, 2605, 2606, 5, 114, 0, 0, - 2606, 2607, 3, 646, 323, 0, 2607, 2609, 5, 464, 0, 0, 2608, 2610, 3, 240, - 120, 0, 2609, 2608, 1, 0, 0, 0, 2609, 2610, 1, 0, 0, 0, 2610, 2611, 1, - 0, 0, 0, 2611, 2613, 5, 465, 0, 0, 2612, 2614, 3, 204, 102, 0, 2613, 2612, - 1, 0, 0, 0, 2613, 2614, 1, 0, 0, 0, 2614, 239, 1, 0, 0, 0, 2615, 2620, - 3, 242, 121, 0, 2616, 2617, 5, 462, 0, 0, 2617, 2619, 3, 242, 121, 0, 2618, - 2616, 1, 0, 0, 0, 2619, 2622, 1, 0, 0, 0, 2620, 2618, 1, 0, 0, 0, 2620, - 2621, 1, 0, 0, 0, 2621, 241, 1, 0, 0, 0, 2622, 2620, 1, 0, 0, 0, 2623, - 2626, 5, 481, 0, 0, 2624, 2626, 3, 172, 86, 0, 2625, 2623, 1, 0, 0, 0, - 2625, 2624, 1, 0, 0, 0, 2626, 2627, 1, 0, 0, 0, 2627, 2628, 5, 451, 0, - 0, 2628, 2629, 3, 608, 304, 0, 2629, 243, 1, 0, 0, 0, 2630, 2631, 5, 64, - 0, 0, 2631, 2632, 5, 33, 0, 0, 2632, 2638, 3, 646, 323, 0, 2633, 2635, - 5, 464, 0, 0, 2634, 2636, 3, 246, 123, 0, 2635, 2634, 1, 0, 0, 0, 2635, - 2636, 1, 0, 0, 0, 2636, 2637, 1, 0, 0, 0, 2637, 2639, 5, 465, 0, 0, 2638, - 2633, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2642, 1, 0, 0, 0, 2640, - 2641, 5, 413, 0, 0, 2641, 2643, 5, 481, 0, 0, 2642, 2640, 1, 0, 0, 0, 2642, - 2643, 1, 0, 0, 0, 2643, 2646, 1, 0, 0, 0, 2644, 2645, 5, 137, 0, 0, 2645, - 2647, 3, 296, 148, 0, 2646, 2644, 1, 0, 0, 0, 2646, 2647, 1, 0, 0, 0, 2647, - 245, 1, 0, 0, 0, 2648, 2653, 3, 248, 124, 0, 2649, 2650, 5, 462, 0, 0, - 2650, 2652, 3, 248, 124, 0, 2651, 2649, 1, 0, 0, 0, 2652, 2655, 1, 0, 0, - 0, 2653, 2651, 1, 0, 0, 0, 2653, 2654, 1, 0, 0, 0, 2654, 247, 1, 0, 0, - 0, 2655, 2653, 1, 0, 0, 0, 2656, 2657, 5, 481, 0, 0, 2657, 2660, 5, 451, - 0, 0, 2658, 2661, 5, 481, 0, 0, 2659, 2661, 3, 608, 304, 0, 2660, 2658, - 1, 0, 0, 0, 2660, 2659, 1, 0, 0, 0, 2661, 2667, 1, 0, 0, 0, 2662, 2663, - 3, 648, 324, 0, 2663, 2664, 5, 470, 0, 0, 2664, 2665, 3, 608, 304, 0, 2665, - 2667, 1, 0, 0, 0, 2666, 2656, 1, 0, 0, 0, 2666, 2662, 1, 0, 0, 0, 2667, - 249, 1, 0, 0, 0, 2668, 2669, 5, 116, 0, 0, 2669, 2670, 5, 33, 0, 0, 2670, - 251, 1, 0, 0, 0, 2671, 2672, 5, 64, 0, 0, 2672, 2673, 5, 364, 0, 0, 2673, - 2674, 5, 33, 0, 0, 2674, 253, 1, 0, 0, 0, 2675, 2676, 5, 64, 0, 0, 2676, - 2677, 5, 392, 0, 0, 2677, 2680, 3, 608, 304, 0, 2678, 2679, 5, 404, 0, - 0, 2679, 2681, 3, 648, 324, 0, 2680, 2678, 1, 0, 0, 0, 2680, 2681, 1, 0, - 0, 0, 2681, 2687, 1, 0, 0, 0, 2682, 2683, 5, 140, 0, 0, 2683, 2684, 5, - 468, 0, 0, 2684, 2685, 3, 644, 322, 0, 2685, 2686, 5, 469, 0, 0, 2686, - 2688, 1, 0, 0, 0, 2687, 2682, 1, 0, 0, 0, 2687, 2688, 1, 0, 0, 0, 2688, - 255, 1, 0, 0, 0, 2689, 2690, 5, 110, 0, 0, 2690, 2691, 3, 608, 304, 0, - 2691, 257, 1, 0, 0, 0, 2692, 2693, 5, 293, 0, 0, 2693, 2694, 5, 294, 0, - 0, 2694, 2695, 3, 192, 96, 0, 2695, 2696, 5, 392, 0, 0, 2696, 2702, 3, - 608, 304, 0, 2697, 2698, 5, 140, 0, 0, 2698, 2699, 5, 468, 0, 0, 2699, - 2700, 3, 644, 322, 0, 2700, 2701, 5, 469, 0, 0, 2701, 2703, 1, 0, 0, 0, - 2702, 2697, 1, 0, 0, 0, 2702, 2703, 1, 0, 0, 0, 2703, 259, 1, 0, 0, 0, - 2704, 2705, 5, 481, 0, 0, 2705, 2707, 5, 451, 0, 0, 2706, 2704, 1, 0, 0, - 0, 2706, 2707, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 2709, 5, 305, - 0, 0, 2709, 2710, 5, 112, 0, 0, 2710, 2711, 3, 262, 131, 0, 2711, 2713, - 3, 264, 132, 0, 2712, 2714, 3, 266, 133, 0, 2713, 2712, 1, 0, 0, 0, 2713, - 2714, 1, 0, 0, 0, 2714, 2718, 1, 0, 0, 0, 2715, 2717, 3, 268, 134, 0, 2716, - 2715, 1, 0, 0, 0, 2717, 2720, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2718, - 2719, 1, 0, 0, 0, 2719, 2722, 1, 0, 0, 0, 2720, 2718, 1, 0, 0, 0, 2721, - 2723, 3, 270, 135, 0, 2722, 2721, 1, 0, 0, 0, 2722, 2723, 1, 0, 0, 0, 2723, - 2725, 1, 0, 0, 0, 2724, 2726, 3, 272, 136, 0, 2725, 2724, 1, 0, 0, 0, 2725, - 2726, 1, 0, 0, 0, 2726, 2728, 1, 0, 0, 0, 2727, 2729, 3, 274, 137, 0, 2728, - 2727, 1, 0, 0, 0, 2728, 2729, 1, 0, 0, 0, 2729, 2730, 1, 0, 0, 0, 2730, - 2732, 3, 276, 138, 0, 2731, 2733, 3, 204, 102, 0, 2732, 2731, 1, 0, 0, - 0, 2732, 2733, 1, 0, 0, 0, 2733, 261, 1, 0, 0, 0, 2734, 2735, 7, 13, 0, - 0, 2735, 263, 1, 0, 0, 0, 2736, 2739, 5, 478, 0, 0, 2737, 2739, 3, 608, - 304, 0, 2738, 2736, 1, 0, 0, 0, 2738, 2737, 1, 0, 0, 0, 2739, 265, 1, 0, - 0, 0, 2740, 2741, 3, 224, 112, 0, 2741, 267, 1, 0, 0, 0, 2742, 2743, 5, - 193, 0, 0, 2743, 2744, 7, 14, 0, 0, 2744, 2745, 5, 451, 0, 0, 2745, 2746, - 3, 608, 304, 0, 2746, 269, 1, 0, 0, 0, 2747, 2748, 5, 310, 0, 0, 2748, - 2749, 5, 312, 0, 0, 2749, 2750, 3, 608, 304, 0, 2750, 2751, 5, 341, 0, - 0, 2751, 2752, 3, 608, 304, 0, 2752, 271, 1, 0, 0, 0, 2753, 2754, 5, 319, - 0, 0, 2754, 2756, 5, 478, 0, 0, 2755, 2757, 3, 224, 112, 0, 2756, 2755, - 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2770, 1, 0, 0, 0, 2758, 2759, - 5, 319, 0, 0, 2759, 2761, 3, 608, 304, 0, 2760, 2762, 3, 224, 112, 0, 2761, - 2760, 1, 0, 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2770, 1, 0, 0, 0, 2763, - 2764, 5, 319, 0, 0, 2764, 2765, 5, 346, 0, 0, 2765, 2766, 3, 646, 323, - 0, 2766, 2767, 5, 70, 0, 0, 2767, 2768, 5, 481, 0, 0, 2768, 2770, 1, 0, - 0, 0, 2769, 2753, 1, 0, 0, 0, 2769, 2758, 1, 0, 0, 0, 2769, 2763, 1, 0, - 0, 0, 2770, 273, 1, 0, 0, 0, 2771, 2772, 5, 318, 0, 0, 2772, 2773, 3, 608, - 304, 0, 2773, 275, 1, 0, 0, 0, 2774, 2775, 5, 76, 0, 0, 2775, 2789, 5, - 257, 0, 0, 2776, 2777, 5, 76, 0, 0, 2777, 2789, 5, 320, 0, 0, 2778, 2779, - 5, 76, 0, 0, 2779, 2780, 5, 346, 0, 0, 2780, 2781, 3, 646, 323, 0, 2781, - 2782, 5, 75, 0, 0, 2782, 2783, 3, 646, 323, 0, 2783, 2789, 1, 0, 0, 0, - 2784, 2785, 5, 76, 0, 0, 2785, 2789, 5, 408, 0, 0, 2786, 2787, 5, 76, 0, - 0, 2787, 2789, 5, 313, 0, 0, 2788, 2774, 1, 0, 0, 0, 2788, 2776, 1, 0, - 0, 0, 2788, 2778, 1, 0, 0, 0, 2788, 2784, 1, 0, 0, 0, 2788, 2786, 1, 0, - 0, 0, 2789, 277, 1, 0, 0, 0, 2790, 2791, 5, 481, 0, 0, 2791, 2792, 5, 451, - 0, 0, 2792, 2793, 3, 280, 140, 0, 2793, 279, 1, 0, 0, 0, 2794, 2795, 5, - 119, 0, 0, 2795, 2796, 5, 464, 0, 0, 2796, 2797, 5, 481, 0, 0, 2797, 2854, - 5, 465, 0, 0, 2798, 2799, 5, 120, 0, 0, 2799, 2800, 5, 464, 0, 0, 2800, - 2801, 5, 481, 0, 0, 2801, 2854, 5, 465, 0, 0, 2802, 2803, 5, 121, 0, 0, - 2803, 2804, 5, 464, 0, 0, 2804, 2805, 5, 481, 0, 0, 2805, 2806, 5, 462, - 0, 0, 2806, 2807, 3, 608, 304, 0, 2807, 2808, 5, 465, 0, 0, 2808, 2854, - 1, 0, 0, 0, 2809, 2810, 5, 183, 0, 0, 2810, 2811, 5, 464, 0, 0, 2811, 2812, - 5, 481, 0, 0, 2812, 2813, 5, 462, 0, 0, 2813, 2814, 3, 608, 304, 0, 2814, - 2815, 5, 465, 0, 0, 2815, 2854, 1, 0, 0, 0, 2816, 2817, 5, 122, 0, 0, 2817, - 2818, 5, 464, 0, 0, 2818, 2819, 5, 481, 0, 0, 2819, 2820, 5, 462, 0, 0, - 2820, 2821, 3, 282, 141, 0, 2821, 2822, 5, 465, 0, 0, 2822, 2854, 1, 0, - 0, 0, 2823, 2824, 5, 123, 0, 0, 2824, 2825, 5, 464, 0, 0, 2825, 2826, 5, - 481, 0, 0, 2826, 2827, 5, 462, 0, 0, 2827, 2828, 5, 481, 0, 0, 2828, 2854, - 5, 465, 0, 0, 2829, 2830, 5, 124, 0, 0, 2830, 2831, 5, 464, 0, 0, 2831, - 2832, 5, 481, 0, 0, 2832, 2833, 5, 462, 0, 0, 2833, 2834, 5, 481, 0, 0, - 2834, 2854, 5, 465, 0, 0, 2835, 2836, 5, 125, 0, 0, 2836, 2837, 5, 464, - 0, 0, 2837, 2838, 5, 481, 0, 0, 2838, 2839, 5, 462, 0, 0, 2839, 2840, 5, - 481, 0, 0, 2840, 2854, 5, 465, 0, 0, 2841, 2842, 5, 126, 0, 0, 2842, 2843, - 5, 464, 0, 0, 2843, 2844, 5, 481, 0, 0, 2844, 2845, 5, 462, 0, 0, 2845, - 2846, 5, 481, 0, 0, 2846, 2854, 5, 465, 0, 0, 2847, 2848, 5, 132, 0, 0, - 2848, 2849, 5, 464, 0, 0, 2849, 2850, 5, 481, 0, 0, 2850, 2851, 5, 462, - 0, 0, 2851, 2852, 5, 481, 0, 0, 2852, 2854, 5, 465, 0, 0, 2853, 2794, 1, - 0, 0, 0, 2853, 2798, 1, 0, 0, 0, 2853, 2802, 1, 0, 0, 0, 2853, 2809, 1, - 0, 0, 0, 2853, 2816, 1, 0, 0, 0, 2853, 2823, 1, 0, 0, 0, 2853, 2829, 1, - 0, 0, 0, 2853, 2835, 1, 0, 0, 0, 2853, 2841, 1, 0, 0, 0, 2853, 2847, 1, - 0, 0, 0, 2854, 281, 1, 0, 0, 0, 2855, 2860, 3, 284, 142, 0, 2856, 2857, - 5, 462, 0, 0, 2857, 2859, 3, 284, 142, 0, 2858, 2856, 1, 0, 0, 0, 2859, - 2862, 1, 0, 0, 0, 2860, 2858, 1, 0, 0, 0, 2860, 2861, 1, 0, 0, 0, 2861, - 283, 1, 0, 0, 0, 2862, 2860, 1, 0, 0, 0, 2863, 2865, 5, 482, 0, 0, 2864, - 2866, 7, 6, 0, 0, 2865, 2864, 1, 0, 0, 0, 2865, 2866, 1, 0, 0, 0, 2866, - 285, 1, 0, 0, 0, 2867, 2868, 5, 481, 0, 0, 2868, 2869, 5, 451, 0, 0, 2869, - 2870, 3, 288, 144, 0, 2870, 287, 1, 0, 0, 0, 2871, 2872, 5, 271, 0, 0, - 2872, 2873, 5, 464, 0, 0, 2873, 2874, 5, 481, 0, 0, 2874, 2896, 5, 465, - 0, 0, 2875, 2876, 5, 272, 0, 0, 2876, 2877, 5, 464, 0, 0, 2877, 2878, 3, - 192, 96, 0, 2878, 2879, 5, 465, 0, 0, 2879, 2896, 1, 0, 0, 0, 2880, 2881, - 5, 127, 0, 0, 2881, 2882, 5, 464, 0, 0, 2882, 2883, 3, 192, 96, 0, 2883, - 2884, 5, 465, 0, 0, 2884, 2896, 1, 0, 0, 0, 2885, 2886, 5, 128, 0, 0, 2886, - 2887, 5, 464, 0, 0, 2887, 2888, 3, 192, 96, 0, 2888, 2889, 5, 465, 0, 0, - 2889, 2896, 1, 0, 0, 0, 2890, 2891, 5, 129, 0, 0, 2891, 2892, 5, 464, 0, - 0, 2892, 2893, 3, 192, 96, 0, 2893, 2894, 5, 465, 0, 0, 2894, 2896, 1, - 0, 0, 0, 2895, 2871, 1, 0, 0, 0, 2895, 2875, 1, 0, 0, 0, 2895, 2880, 1, - 0, 0, 0, 2895, 2885, 1, 0, 0, 0, 2895, 2890, 1, 0, 0, 0, 2896, 289, 1, - 0, 0, 0, 2897, 2898, 5, 481, 0, 0, 2898, 2899, 5, 451, 0, 0, 2899, 2900, - 5, 17, 0, 0, 2900, 2901, 5, 13, 0, 0, 2901, 2902, 3, 646, 323, 0, 2902, - 291, 1, 0, 0, 0, 2903, 2904, 5, 46, 0, 0, 2904, 2905, 5, 481, 0, 0, 2905, - 2906, 5, 410, 0, 0, 2906, 2907, 5, 481, 0, 0, 2907, 293, 1, 0, 0, 0, 2908, - 2909, 5, 131, 0, 0, 2909, 2910, 5, 481, 0, 0, 2910, 2911, 5, 70, 0, 0, - 2911, 2912, 5, 481, 0, 0, 2912, 295, 1, 0, 0, 0, 2913, 2918, 3, 298, 149, - 0, 2914, 2915, 5, 462, 0, 0, 2915, 2917, 3, 298, 149, 0, 2916, 2914, 1, - 0, 0, 0, 2917, 2920, 1, 0, 0, 0, 2918, 2916, 1, 0, 0, 0, 2918, 2919, 1, - 0, 0, 0, 2919, 297, 1, 0, 0, 0, 2920, 2918, 1, 0, 0, 0, 2921, 2922, 3, - 300, 150, 0, 2922, 2923, 5, 451, 0, 0, 2923, 2924, 3, 608, 304, 0, 2924, - 299, 1, 0, 0, 0, 2925, 2930, 3, 646, 323, 0, 2926, 2930, 5, 482, 0, 0, - 2927, 2930, 5, 484, 0, 0, 2928, 2930, 3, 668, 334, 0, 2929, 2925, 1, 0, - 0, 0, 2929, 2926, 1, 0, 0, 0, 2929, 2927, 1, 0, 0, 0, 2929, 2928, 1, 0, - 0, 0, 2930, 301, 1, 0, 0, 0, 2931, 2936, 3, 304, 152, 0, 2932, 2933, 5, - 462, 0, 0, 2933, 2935, 3, 304, 152, 0, 2934, 2932, 1, 0, 0, 0, 2935, 2938, - 1, 0, 0, 0, 2936, 2934, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 303, - 1, 0, 0, 0, 2938, 2936, 1, 0, 0, 0, 2939, 2940, 5, 482, 0, 0, 2940, 2941, - 5, 451, 0, 0, 2941, 2942, 3, 608, 304, 0, 2942, 305, 1, 0, 0, 0, 2943, - 2944, 5, 33, 0, 0, 2944, 2945, 3, 646, 323, 0, 2945, 2946, 3, 356, 178, - 0, 2946, 2947, 5, 466, 0, 0, 2947, 2948, 3, 364, 182, 0, 2948, 2949, 5, - 467, 0, 0, 2949, 307, 1, 0, 0, 0, 2950, 2951, 5, 34, 0, 0, 2951, 2953, - 3, 646, 323, 0, 2952, 2954, 3, 360, 180, 0, 2953, 2952, 1, 0, 0, 0, 2953, - 2954, 1, 0, 0, 0, 2954, 2956, 1, 0, 0, 0, 2955, 2957, 3, 310, 155, 0, 2956, - 2955, 1, 0, 0, 0, 2956, 2957, 1, 0, 0, 0, 2957, 2958, 1, 0, 0, 0, 2958, - 2959, 5, 466, 0, 0, 2959, 2960, 3, 364, 182, 0, 2960, 2961, 5, 467, 0, - 0, 2961, 309, 1, 0, 0, 0, 2962, 2964, 3, 312, 156, 0, 2963, 2962, 1, 0, - 0, 0, 2964, 2965, 1, 0, 0, 0, 2965, 2963, 1, 0, 0, 0, 2965, 2966, 1, 0, - 0, 0, 2966, 311, 1, 0, 0, 0, 2967, 2968, 5, 215, 0, 0, 2968, 2969, 5, 478, - 0, 0, 2969, 313, 1, 0, 0, 0, 2970, 2975, 3, 316, 158, 0, 2971, 2972, 5, - 462, 0, 0, 2972, 2974, 3, 316, 158, 0, 2973, 2971, 1, 0, 0, 0, 2974, 2977, - 1, 0, 0, 0, 2975, 2973, 1, 0, 0, 0, 2975, 2976, 1, 0, 0, 0, 2976, 315, - 1, 0, 0, 0, 2977, 2975, 1, 0, 0, 0, 2978, 2979, 7, 15, 0, 0, 2979, 2980, - 5, 470, 0, 0, 2980, 2981, 3, 98, 49, 0, 2981, 317, 1, 0, 0, 0, 2982, 2987, - 3, 320, 160, 0, 2983, 2984, 5, 462, 0, 0, 2984, 2986, 3, 320, 160, 0, 2985, - 2983, 1, 0, 0, 0, 2986, 2989, 1, 0, 0, 0, 2987, 2985, 1, 0, 0, 0, 2987, - 2988, 1, 0, 0, 0, 2988, 319, 1, 0, 0, 0, 2989, 2987, 1, 0, 0, 0, 2990, - 2991, 7, 15, 0, 0, 2991, 2992, 5, 470, 0, 0, 2992, 2993, 3, 98, 49, 0, - 2993, 321, 1, 0, 0, 0, 2994, 2999, 3, 324, 162, 0, 2995, 2996, 5, 462, - 0, 0, 2996, 2998, 3, 324, 162, 0, 2997, 2995, 1, 0, 0, 0, 2998, 3001, 1, - 0, 0, 0, 2999, 2997, 1, 0, 0, 0, 2999, 3000, 1, 0, 0, 0, 3000, 323, 1, - 0, 0, 0, 3001, 2999, 1, 0, 0, 0, 3002, 3003, 5, 481, 0, 0, 3003, 3004, - 5, 470, 0, 0, 3004, 3005, 3, 98, 49, 0, 3005, 3006, 5, 451, 0, 0, 3006, - 3007, 5, 478, 0, 0, 3007, 325, 1, 0, 0, 0, 3008, 3011, 3, 646, 323, 0, - 3009, 3011, 5, 482, 0, 0, 3010, 3008, 1, 0, 0, 0, 3010, 3009, 1, 0, 0, - 0, 3011, 3013, 1, 0, 0, 0, 3012, 3014, 7, 6, 0, 0, 3013, 3012, 1, 0, 0, - 0, 3013, 3014, 1, 0, 0, 0, 3014, 327, 1, 0, 0, 0, 3015, 3016, 5, 468, 0, - 0, 3016, 3017, 3, 332, 166, 0, 3017, 3018, 5, 469, 0, 0, 3018, 329, 1, - 0, 0, 0, 3019, 3020, 7, 16, 0, 0, 3020, 331, 1, 0, 0, 0, 3021, 3026, 3, - 334, 167, 0, 3022, 3023, 5, 281, 0, 0, 3023, 3025, 3, 334, 167, 0, 3024, - 3022, 1, 0, 0, 0, 3025, 3028, 1, 0, 0, 0, 3026, 3024, 1, 0, 0, 0, 3026, - 3027, 1, 0, 0, 0, 3027, 333, 1, 0, 0, 0, 3028, 3026, 1, 0, 0, 0, 3029, - 3034, 3, 336, 168, 0, 3030, 3031, 5, 280, 0, 0, 3031, 3033, 3, 336, 168, - 0, 3032, 3030, 1, 0, 0, 0, 3033, 3036, 1, 0, 0, 0, 3034, 3032, 1, 0, 0, - 0, 3034, 3035, 1, 0, 0, 0, 3035, 335, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, - 0, 3037, 3038, 5, 282, 0, 0, 3038, 3041, 3, 336, 168, 0, 3039, 3041, 3, - 338, 169, 0, 3040, 3037, 1, 0, 0, 0, 3040, 3039, 1, 0, 0, 0, 3041, 337, - 1, 0, 0, 0, 3042, 3046, 3, 340, 170, 0, 3043, 3044, 3, 618, 309, 0, 3044, - 3045, 3, 340, 170, 0, 3045, 3047, 1, 0, 0, 0, 3046, 3043, 1, 0, 0, 0, 3046, - 3047, 1, 0, 0, 0, 3047, 339, 1, 0, 0, 0, 3048, 3055, 3, 352, 176, 0, 3049, - 3055, 3, 342, 171, 0, 3050, 3051, 5, 464, 0, 0, 3051, 3052, 3, 332, 166, - 0, 3052, 3053, 5, 465, 0, 0, 3053, 3055, 1, 0, 0, 0, 3054, 3048, 1, 0, - 0, 0, 3054, 3049, 1, 0, 0, 0, 3054, 3050, 1, 0, 0, 0, 3055, 341, 1, 0, - 0, 0, 3056, 3061, 3, 344, 172, 0, 3057, 3058, 5, 457, 0, 0, 3058, 3060, - 3, 344, 172, 0, 3059, 3057, 1, 0, 0, 0, 3060, 3063, 1, 0, 0, 0, 3061, 3059, - 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 343, 1, 0, 0, 0, 3063, 3061, - 1, 0, 0, 0, 3064, 3069, 3, 346, 173, 0, 3065, 3066, 5, 468, 0, 0, 3066, - 3067, 3, 332, 166, 0, 3067, 3068, 5, 469, 0, 0, 3068, 3070, 1, 0, 0, 0, - 3069, 3065, 1, 0, 0, 0, 3069, 3070, 1, 0, 0, 0, 3070, 345, 1, 0, 0, 0, - 3071, 3077, 3, 348, 174, 0, 3072, 3077, 5, 481, 0, 0, 3073, 3077, 5, 478, - 0, 0, 3074, 3077, 5, 480, 0, 0, 3075, 3077, 5, 477, 0, 0, 3076, 3071, 1, - 0, 0, 0, 3076, 3072, 1, 0, 0, 0, 3076, 3073, 1, 0, 0, 0, 3076, 3074, 1, - 0, 0, 0, 3076, 3075, 1, 0, 0, 0, 3077, 347, 1, 0, 0, 0, 3078, 3083, 3, - 350, 175, 0, 3079, 3080, 5, 463, 0, 0, 3080, 3082, 3, 350, 175, 0, 3081, - 3079, 1, 0, 0, 0, 3082, 3085, 1, 0, 0, 0, 3083, 3081, 1, 0, 0, 0, 3083, - 3084, 1, 0, 0, 0, 3084, 349, 1, 0, 0, 0, 3085, 3083, 1, 0, 0, 0, 3086, - 3087, 8, 17, 0, 0, 3087, 351, 1, 0, 0, 0, 3088, 3089, 3, 354, 177, 0, 3089, - 3098, 5, 464, 0, 0, 3090, 3095, 3, 332, 166, 0, 3091, 3092, 5, 462, 0, - 0, 3092, 3094, 3, 332, 166, 0, 3093, 3091, 1, 0, 0, 0, 3094, 3097, 1, 0, - 0, 0, 3095, 3093, 1, 0, 0, 0, 3095, 3096, 1, 0, 0, 0, 3096, 3099, 1, 0, - 0, 0, 3097, 3095, 1, 0, 0, 0, 3098, 3090, 1, 0, 0, 0, 3098, 3099, 1, 0, - 0, 0, 3099, 3100, 1, 0, 0, 0, 3100, 3101, 5, 465, 0, 0, 3101, 353, 1, 0, - 0, 0, 3102, 3103, 7, 18, 0, 0, 3103, 355, 1, 0, 0, 0, 3104, 3105, 5, 464, - 0, 0, 3105, 3110, 3, 358, 179, 0, 3106, 3107, 5, 462, 0, 0, 3107, 3109, - 3, 358, 179, 0, 3108, 3106, 1, 0, 0, 0, 3109, 3112, 1, 0, 0, 0, 3110, 3108, - 1, 0, 0, 0, 3110, 3111, 1, 0, 0, 0, 3111, 3113, 1, 0, 0, 0, 3112, 3110, - 1, 0, 0, 0, 3113, 3114, 5, 465, 0, 0, 3114, 357, 1, 0, 0, 0, 3115, 3116, - 5, 200, 0, 0, 3116, 3117, 5, 470, 0, 0, 3117, 3118, 5, 466, 0, 0, 3118, - 3119, 3, 314, 157, 0, 3119, 3120, 5, 467, 0, 0, 3120, 3143, 1, 0, 0, 0, - 3121, 3122, 5, 201, 0, 0, 3122, 3123, 5, 470, 0, 0, 3123, 3124, 5, 466, - 0, 0, 3124, 3125, 3, 322, 161, 0, 3125, 3126, 5, 467, 0, 0, 3126, 3143, - 1, 0, 0, 0, 3127, 3128, 5, 162, 0, 0, 3128, 3129, 5, 470, 0, 0, 3129, 3143, - 5, 478, 0, 0, 3130, 3131, 5, 35, 0, 0, 3131, 3134, 5, 470, 0, 0, 3132, - 3135, 3, 646, 323, 0, 3133, 3135, 5, 478, 0, 0, 3134, 3132, 1, 0, 0, 0, - 3134, 3133, 1, 0, 0, 0, 3135, 3143, 1, 0, 0, 0, 3136, 3137, 5, 214, 0, - 0, 3137, 3138, 5, 470, 0, 0, 3138, 3143, 5, 478, 0, 0, 3139, 3140, 5, 215, - 0, 0, 3140, 3141, 5, 470, 0, 0, 3141, 3143, 5, 478, 0, 0, 3142, 3115, 1, - 0, 0, 0, 3142, 3121, 1, 0, 0, 0, 3142, 3127, 1, 0, 0, 0, 3142, 3130, 1, - 0, 0, 0, 3142, 3136, 1, 0, 0, 0, 3142, 3139, 1, 0, 0, 0, 3143, 359, 1, - 0, 0, 0, 3144, 3145, 5, 464, 0, 0, 3145, 3150, 3, 362, 181, 0, 3146, 3147, - 5, 462, 0, 0, 3147, 3149, 3, 362, 181, 0, 3148, 3146, 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, 5, 465, 0, 0, 3154, - 361, 1, 0, 0, 0, 3155, 3156, 5, 200, 0, 0, 3156, 3157, 5, 470, 0, 0, 3157, - 3158, 5, 466, 0, 0, 3158, 3159, 3, 318, 159, 0, 3159, 3160, 5, 467, 0, - 0, 3160, 3171, 1, 0, 0, 0, 3161, 3162, 5, 201, 0, 0, 3162, 3163, 5, 470, - 0, 0, 3163, 3164, 5, 466, 0, 0, 3164, 3165, 3, 322, 161, 0, 3165, 3166, - 5, 467, 0, 0, 3166, 3171, 1, 0, 0, 0, 3167, 3168, 5, 215, 0, 0, 3168, 3169, - 5, 470, 0, 0, 3169, 3171, 5, 478, 0, 0, 3170, 3155, 1, 0, 0, 0, 3170, 3161, - 1, 0, 0, 0, 3170, 3167, 1, 0, 0, 0, 3171, 363, 1, 0, 0, 0, 3172, 3175, - 3, 368, 184, 0, 3173, 3175, 3, 366, 183, 0, 3174, 3172, 1, 0, 0, 0, 3174, - 3173, 1, 0, 0, 0, 3175, 3178, 1, 0, 0, 0, 3176, 3174, 1, 0, 0, 0, 3176, - 3177, 1, 0, 0, 0, 3177, 365, 1, 0, 0, 0, 3178, 3176, 1, 0, 0, 0, 3179, - 3180, 5, 66, 0, 0, 3180, 3181, 5, 377, 0, 0, 3181, 3184, 3, 648, 324, 0, - 3182, 3183, 5, 75, 0, 0, 3183, 3185, 3, 648, 324, 0, 3184, 3182, 1, 0, - 0, 0, 3184, 3185, 1, 0, 0, 0, 3185, 367, 1, 0, 0, 0, 3186, 3187, 3, 370, - 185, 0, 3187, 3189, 5, 482, 0, 0, 3188, 3190, 3, 372, 186, 0, 3189, 3188, - 1, 0, 0, 0, 3189, 3190, 1, 0, 0, 0, 3190, 3192, 1, 0, 0, 0, 3191, 3193, - 3, 410, 205, 0, 3192, 3191, 1, 0, 0, 0, 3192, 3193, 1, 0, 0, 0, 3193, 369, - 1, 0, 0, 0, 3194, 3195, 7, 19, 0, 0, 3195, 371, 1, 0, 0, 0, 3196, 3197, - 5, 464, 0, 0, 3197, 3202, 3, 374, 187, 0, 3198, 3199, 5, 462, 0, 0, 3199, - 3201, 3, 374, 187, 0, 3200, 3198, 1, 0, 0, 0, 3201, 3204, 1, 0, 0, 0, 3202, - 3200, 1, 0, 0, 0, 3202, 3203, 1, 0, 0, 0, 3203, 3205, 1, 0, 0, 0, 3204, - 3202, 1, 0, 0, 0, 3205, 3206, 5, 465, 0, 0, 3206, 373, 1, 0, 0, 0, 3207, - 3208, 5, 189, 0, 0, 3208, 3209, 5, 470, 0, 0, 3209, 3283, 3, 380, 190, - 0, 3210, 3211, 5, 38, 0, 0, 3211, 3212, 5, 470, 0, 0, 3212, 3283, 3, 388, - 194, 0, 3213, 3214, 5, 196, 0, 0, 3214, 3215, 5, 470, 0, 0, 3215, 3283, - 3, 388, 194, 0, 3216, 3217, 5, 114, 0, 0, 3217, 3218, 5, 470, 0, 0, 3218, - 3283, 3, 382, 191, 0, 3219, 3220, 5, 186, 0, 0, 3220, 3221, 5, 470, 0, - 0, 3221, 3283, 3, 390, 195, 0, 3222, 3223, 5, 166, 0, 0, 3223, 3224, 5, - 470, 0, 0, 3224, 3283, 5, 478, 0, 0, 3225, 3226, 5, 197, 0, 0, 3226, 3227, - 5, 470, 0, 0, 3227, 3283, 3, 388, 194, 0, 3228, 3229, 5, 194, 0, 0, 3229, - 3230, 5, 470, 0, 0, 3230, 3283, 3, 390, 195, 0, 3231, 3232, 5, 195, 0, - 0, 3232, 3233, 5, 470, 0, 0, 3233, 3283, 3, 396, 198, 0, 3234, 3235, 5, - 198, 0, 0, 3235, 3236, 5, 470, 0, 0, 3236, 3283, 3, 392, 196, 0, 3237, - 3238, 5, 199, 0, 0, 3238, 3239, 5, 470, 0, 0, 3239, 3283, 3, 392, 196, - 0, 3240, 3241, 5, 205, 0, 0, 3241, 3242, 5, 470, 0, 0, 3242, 3283, 3, 398, - 199, 0, 3243, 3244, 5, 203, 0, 0, 3244, 3245, 5, 470, 0, 0, 3245, 3283, - 5, 478, 0, 0, 3246, 3247, 5, 204, 0, 0, 3247, 3248, 5, 470, 0, 0, 3248, - 3283, 5, 478, 0, 0, 3249, 3250, 5, 202, 0, 0, 3250, 3251, 5, 470, 0, 0, - 3251, 3283, 3, 400, 200, 0, 3252, 3253, 5, 191, 0, 0, 3253, 3254, 5, 470, - 0, 0, 3254, 3283, 3, 402, 201, 0, 3255, 3256, 5, 34, 0, 0, 3256, 3257, - 5, 470, 0, 0, 3257, 3283, 3, 646, 323, 0, 3258, 3259, 5, 220, 0, 0, 3259, - 3260, 5, 470, 0, 0, 3260, 3283, 3, 378, 189, 0, 3261, 3262, 5, 221, 0, - 0, 3262, 3263, 5, 470, 0, 0, 3263, 3283, 3, 376, 188, 0, 3264, 3265, 5, - 208, 0, 0, 3265, 3266, 5, 470, 0, 0, 3266, 3283, 3, 406, 203, 0, 3267, - 3268, 5, 211, 0, 0, 3268, 3269, 5, 470, 0, 0, 3269, 3283, 5, 480, 0, 0, - 3270, 3271, 5, 212, 0, 0, 3271, 3272, 5, 470, 0, 0, 3272, 3283, 5, 480, - 0, 0, 3273, 3274, 5, 227, 0, 0, 3274, 3275, 5, 470, 0, 0, 3275, 3283, 3, - 404, 202, 0, 3276, 3277, 5, 188, 0, 0, 3277, 3278, 5, 470, 0, 0, 3278, - 3283, 3, 404, 202, 0, 3279, 3280, 5, 482, 0, 0, 3280, 3281, 5, 470, 0, - 0, 3281, 3283, 3, 404, 202, 0, 3282, 3207, 1, 0, 0, 0, 3282, 3210, 1, 0, - 0, 0, 3282, 3213, 1, 0, 0, 0, 3282, 3216, 1, 0, 0, 0, 3282, 3219, 1, 0, - 0, 0, 3282, 3222, 1, 0, 0, 0, 3282, 3225, 1, 0, 0, 0, 3282, 3228, 1, 0, - 0, 0, 3282, 3231, 1, 0, 0, 0, 3282, 3234, 1, 0, 0, 0, 3282, 3237, 1, 0, - 0, 0, 3282, 3240, 1, 0, 0, 0, 3282, 3243, 1, 0, 0, 0, 3282, 3246, 1, 0, - 0, 0, 3282, 3249, 1, 0, 0, 0, 3282, 3252, 1, 0, 0, 0, 3282, 3255, 1, 0, - 0, 0, 3282, 3258, 1, 0, 0, 0, 3282, 3261, 1, 0, 0, 0, 3282, 3264, 1, 0, - 0, 0, 3282, 3267, 1, 0, 0, 0, 3282, 3270, 1, 0, 0, 0, 3282, 3273, 1, 0, - 0, 0, 3282, 3276, 1, 0, 0, 0, 3282, 3279, 1, 0, 0, 0, 3283, 375, 1, 0, - 0, 0, 3284, 3285, 7, 20, 0, 0, 3285, 377, 1, 0, 0, 0, 3286, 3287, 5, 468, - 0, 0, 3287, 3292, 3, 646, 323, 0, 3288, 3289, 5, 462, 0, 0, 3289, 3291, - 3, 646, 323, 0, 3290, 3288, 1, 0, 0, 0, 3291, 3294, 1, 0, 0, 0, 3292, 3290, - 1, 0, 0, 0, 3292, 3293, 1, 0, 0, 0, 3293, 3295, 1, 0, 0, 0, 3294, 3292, - 1, 0, 0, 0, 3295, 3296, 5, 469, 0, 0, 3296, 379, 1, 0, 0, 0, 3297, 3344, - 5, 481, 0, 0, 3298, 3300, 5, 343, 0, 0, 3299, 3301, 5, 70, 0, 0, 3300, - 3299, 1, 0, 0, 0, 3300, 3301, 1, 0, 0, 0, 3301, 3302, 1, 0, 0, 0, 3302, - 3316, 3, 646, 323, 0, 3303, 3314, 5, 71, 0, 0, 3304, 3310, 3, 328, 164, - 0, 3305, 3306, 3, 330, 165, 0, 3306, 3307, 3, 328, 164, 0, 3307, 3309, - 1, 0, 0, 0, 3308, 3305, 1, 0, 0, 0, 3309, 3312, 1, 0, 0, 0, 3310, 3308, - 1, 0, 0, 0, 3310, 3311, 1, 0, 0, 0, 3311, 3315, 1, 0, 0, 0, 3312, 3310, - 1, 0, 0, 0, 3313, 3315, 3, 608, 304, 0, 3314, 3304, 1, 0, 0, 0, 3314, 3313, - 1, 0, 0, 0, 3315, 3317, 1, 0, 0, 0, 3316, 3303, 1, 0, 0, 0, 3316, 3317, - 1, 0, 0, 0, 3317, 3327, 1, 0, 0, 0, 3318, 3319, 5, 10, 0, 0, 3319, 3324, - 3, 326, 163, 0, 3320, 3321, 5, 462, 0, 0, 3321, 3323, 3, 326, 163, 0, 3322, - 3320, 1, 0, 0, 0, 3323, 3326, 1, 0, 0, 0, 3324, 3322, 1, 0, 0, 0, 3324, - 3325, 1, 0, 0, 0, 3325, 3328, 1, 0, 0, 0, 3326, 3324, 1, 0, 0, 0, 3327, - 3318, 1, 0, 0, 0, 3327, 3328, 1, 0, 0, 0, 3328, 3344, 1, 0, 0, 0, 3329, - 3330, 5, 30, 0, 0, 3330, 3332, 3, 646, 323, 0, 3331, 3333, 3, 384, 192, - 0, 3332, 3331, 1, 0, 0, 0, 3332, 3333, 1, 0, 0, 0, 3333, 3344, 1, 0, 0, - 0, 3334, 3335, 5, 31, 0, 0, 3335, 3337, 3, 646, 323, 0, 3336, 3338, 3, - 384, 192, 0, 3337, 3336, 1, 0, 0, 0, 3337, 3338, 1, 0, 0, 0, 3338, 3344, - 1, 0, 0, 0, 3339, 3340, 5, 27, 0, 0, 3340, 3344, 3, 388, 194, 0, 3341, - 3342, 5, 191, 0, 0, 3342, 3344, 5, 482, 0, 0, 3343, 3297, 1, 0, 0, 0, 3343, - 3298, 1, 0, 0, 0, 3343, 3329, 1, 0, 0, 0, 3343, 3334, 1, 0, 0, 0, 3343, - 3339, 1, 0, 0, 0, 3343, 3341, 1, 0, 0, 0, 3344, 381, 1, 0, 0, 0, 3345, - 3347, 5, 229, 0, 0, 3346, 3348, 5, 231, 0, 0, 3347, 3346, 1, 0, 0, 0, 3347, - 3348, 1, 0, 0, 0, 3348, 3384, 1, 0, 0, 0, 3349, 3351, 5, 230, 0, 0, 3350, - 3352, 5, 231, 0, 0, 3351, 3350, 1, 0, 0, 0, 3351, 3352, 1, 0, 0, 0, 3352, - 3384, 1, 0, 0, 0, 3353, 3384, 5, 231, 0, 0, 3354, 3384, 5, 234, 0, 0, 3355, - 3357, 5, 99, 0, 0, 3356, 3358, 5, 231, 0, 0, 3357, 3356, 1, 0, 0, 0, 3357, - 3358, 1, 0, 0, 0, 3358, 3384, 1, 0, 0, 0, 3359, 3360, 5, 235, 0, 0, 3360, - 3363, 3, 646, 323, 0, 3361, 3362, 5, 80, 0, 0, 3362, 3364, 3, 382, 191, - 0, 3363, 3361, 1, 0, 0, 0, 3363, 3364, 1, 0, 0, 0, 3364, 3384, 1, 0, 0, - 0, 3365, 3366, 5, 232, 0, 0, 3366, 3368, 3, 646, 323, 0, 3367, 3369, 3, - 384, 192, 0, 3368, 3367, 1, 0, 0, 0, 3368, 3369, 1, 0, 0, 0, 3369, 3384, - 1, 0, 0, 0, 3370, 3371, 5, 30, 0, 0, 3371, 3373, 3, 646, 323, 0, 3372, - 3374, 3, 384, 192, 0, 3373, 3372, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, - 3384, 1, 0, 0, 0, 3375, 3376, 5, 31, 0, 0, 3376, 3378, 3, 646, 323, 0, - 3377, 3379, 3, 384, 192, 0, 3378, 3377, 1, 0, 0, 0, 3378, 3379, 1, 0, 0, - 0, 3379, 3384, 1, 0, 0, 0, 3380, 3381, 5, 238, 0, 0, 3381, 3384, 5, 478, - 0, 0, 3382, 3384, 5, 239, 0, 0, 3383, 3345, 1, 0, 0, 0, 3383, 3349, 1, - 0, 0, 0, 3383, 3353, 1, 0, 0, 0, 3383, 3354, 1, 0, 0, 0, 3383, 3355, 1, - 0, 0, 0, 3383, 3359, 1, 0, 0, 0, 3383, 3365, 1, 0, 0, 0, 3383, 3370, 1, - 0, 0, 0, 3383, 3375, 1, 0, 0, 0, 3383, 3380, 1, 0, 0, 0, 3383, 3382, 1, - 0, 0, 0, 3384, 383, 1, 0, 0, 0, 3385, 3386, 5, 464, 0, 0, 3386, 3391, 3, - 386, 193, 0, 3387, 3388, 5, 462, 0, 0, 3388, 3390, 3, 386, 193, 0, 3389, - 3387, 1, 0, 0, 0, 3390, 3393, 1, 0, 0, 0, 3391, 3389, 1, 0, 0, 0, 3391, - 3392, 1, 0, 0, 0, 3392, 3394, 1, 0, 0, 0, 3393, 3391, 1, 0, 0, 0, 3394, - 3395, 5, 465, 0, 0, 3395, 385, 1, 0, 0, 0, 3396, 3397, 5, 482, 0, 0, 3397, - 3398, 5, 470, 0, 0, 3398, 3403, 3, 608, 304, 0, 3399, 3400, 5, 481, 0, - 0, 3400, 3401, 5, 451, 0, 0, 3401, 3403, 3, 608, 304, 0, 3402, 3396, 1, - 0, 0, 0, 3402, 3399, 1, 0, 0, 0, 3403, 387, 1, 0, 0, 0, 3404, 3408, 5, - 482, 0, 0, 3405, 3408, 5, 484, 0, 0, 3406, 3408, 3, 670, 335, 0, 3407, - 3404, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3407, 3406, 1, 0, 0, 0, 3408, - 3417, 1, 0, 0, 0, 3409, 3413, 5, 457, 0, 0, 3410, 3414, 5, 482, 0, 0, 3411, - 3414, 5, 484, 0, 0, 3412, 3414, 3, 670, 335, 0, 3413, 3410, 1, 0, 0, 0, - 3413, 3411, 1, 0, 0, 0, 3413, 3412, 1, 0, 0, 0, 3414, 3416, 1, 0, 0, 0, - 3415, 3409, 1, 0, 0, 0, 3416, 3419, 1, 0, 0, 0, 3417, 3415, 1, 0, 0, 0, - 3417, 3418, 1, 0, 0, 0, 3418, 389, 1, 0, 0, 0, 3419, 3417, 1, 0, 0, 0, - 3420, 3431, 5, 478, 0, 0, 3421, 3431, 3, 388, 194, 0, 3422, 3428, 5, 481, - 0, 0, 3423, 3426, 5, 463, 0, 0, 3424, 3427, 5, 482, 0, 0, 3425, 3427, 3, - 670, 335, 0, 3426, 3424, 1, 0, 0, 0, 3426, 3425, 1, 0, 0, 0, 3427, 3429, - 1, 0, 0, 0, 3428, 3423, 1, 0, 0, 0, 3428, 3429, 1, 0, 0, 0, 3429, 3431, - 1, 0, 0, 0, 3430, 3420, 1, 0, 0, 0, 3430, 3421, 1, 0, 0, 0, 3430, 3422, - 1, 0, 0, 0, 3431, 391, 1, 0, 0, 0, 3432, 3433, 5, 468, 0, 0, 3433, 3438, - 3, 394, 197, 0, 3434, 3435, 5, 462, 0, 0, 3435, 3437, 3, 394, 197, 0, 3436, - 3434, 1, 0, 0, 0, 3437, 3440, 1, 0, 0, 0, 3438, 3436, 1, 0, 0, 0, 3438, - 3439, 1, 0, 0, 0, 3439, 3441, 1, 0, 0, 0, 3440, 3438, 1, 0, 0, 0, 3441, - 3442, 5, 469, 0, 0, 3442, 393, 1, 0, 0, 0, 3443, 3444, 5, 466, 0, 0, 3444, - 3445, 5, 480, 0, 0, 3445, 3446, 5, 467, 0, 0, 3446, 3447, 5, 451, 0, 0, - 3447, 3448, 3, 608, 304, 0, 3448, 395, 1, 0, 0, 0, 3449, 3450, 7, 21, 0, - 0, 3450, 397, 1, 0, 0, 0, 3451, 3452, 7, 22, 0, 0, 3452, 399, 1, 0, 0, - 0, 3453, 3454, 7, 23, 0, 0, 3454, 401, 1, 0, 0, 0, 3455, 3456, 7, 24, 0, - 0, 3456, 403, 1, 0, 0, 0, 3457, 3481, 5, 478, 0, 0, 3458, 3481, 5, 480, - 0, 0, 3459, 3481, 3, 654, 327, 0, 3460, 3481, 3, 646, 323, 0, 3461, 3481, - 5, 482, 0, 0, 3462, 3481, 5, 250, 0, 0, 3463, 3481, 5, 251, 0, 0, 3464, - 3481, 5, 252, 0, 0, 3465, 3481, 5, 253, 0, 0, 3466, 3481, 5, 254, 0, 0, - 3467, 3481, 5, 255, 0, 0, 3468, 3477, 5, 468, 0, 0, 3469, 3474, 3, 608, - 304, 0, 3470, 3471, 5, 462, 0, 0, 3471, 3473, 3, 608, 304, 0, 3472, 3470, - 1, 0, 0, 0, 3473, 3476, 1, 0, 0, 0, 3474, 3472, 1, 0, 0, 0, 3474, 3475, - 1, 0, 0, 0, 3475, 3478, 1, 0, 0, 0, 3476, 3474, 1, 0, 0, 0, 3477, 3469, - 1, 0, 0, 0, 3477, 3478, 1, 0, 0, 0, 3478, 3479, 1, 0, 0, 0, 3479, 3481, - 5, 469, 0, 0, 3480, 3457, 1, 0, 0, 0, 3480, 3458, 1, 0, 0, 0, 3480, 3459, - 1, 0, 0, 0, 3480, 3460, 1, 0, 0, 0, 3480, 3461, 1, 0, 0, 0, 3480, 3462, - 1, 0, 0, 0, 3480, 3463, 1, 0, 0, 0, 3480, 3464, 1, 0, 0, 0, 3480, 3465, - 1, 0, 0, 0, 3480, 3466, 1, 0, 0, 0, 3480, 3467, 1, 0, 0, 0, 3480, 3468, - 1, 0, 0, 0, 3481, 405, 1, 0, 0, 0, 3482, 3483, 5, 468, 0, 0, 3483, 3488, - 3, 408, 204, 0, 3484, 3485, 5, 462, 0, 0, 3485, 3487, 3, 408, 204, 0, 3486, - 3484, 1, 0, 0, 0, 3487, 3490, 1, 0, 0, 0, 3488, 3486, 1, 0, 0, 0, 3488, - 3489, 1, 0, 0, 0, 3489, 3491, 1, 0, 0, 0, 3490, 3488, 1, 0, 0, 0, 3491, - 3492, 5, 469, 0, 0, 3492, 3496, 1, 0, 0, 0, 3493, 3494, 5, 468, 0, 0, 3494, - 3496, 5, 469, 0, 0, 3495, 3482, 1, 0, 0, 0, 3495, 3493, 1, 0, 0, 0, 3496, - 407, 1, 0, 0, 0, 3497, 3498, 5, 478, 0, 0, 3498, 3499, 5, 470, 0, 0, 3499, - 3507, 5, 478, 0, 0, 3500, 3501, 5, 478, 0, 0, 3501, 3502, 5, 470, 0, 0, - 3502, 3507, 5, 92, 0, 0, 3503, 3504, 5, 478, 0, 0, 3504, 3505, 5, 470, - 0, 0, 3505, 3507, 5, 446, 0, 0, 3506, 3497, 1, 0, 0, 0, 3506, 3500, 1, - 0, 0, 0, 3506, 3503, 1, 0, 0, 0, 3507, 409, 1, 0, 0, 0, 3508, 3509, 5, - 466, 0, 0, 3509, 3510, 3, 364, 182, 0, 3510, 3511, 5, 467, 0, 0, 3511, - 411, 1, 0, 0, 0, 3512, 3513, 5, 36, 0, 0, 3513, 3515, 3, 646, 323, 0, 3514, - 3516, 3, 414, 207, 0, 3515, 3514, 1, 0, 0, 0, 3515, 3516, 1, 0, 0, 0, 3516, - 3517, 1, 0, 0, 0, 3517, 3521, 5, 95, 0, 0, 3518, 3520, 3, 418, 209, 0, - 3519, 3518, 1, 0, 0, 0, 3520, 3523, 1, 0, 0, 0, 3521, 3519, 1, 0, 0, 0, - 3521, 3522, 1, 0, 0, 0, 3522, 3524, 1, 0, 0, 0, 3523, 3521, 1, 0, 0, 0, - 3524, 3525, 5, 82, 0, 0, 3525, 413, 1, 0, 0, 0, 3526, 3528, 3, 416, 208, - 0, 3527, 3526, 1, 0, 0, 0, 3528, 3529, 1, 0, 0, 0, 3529, 3527, 1, 0, 0, - 0, 3529, 3530, 1, 0, 0, 0, 3530, 415, 1, 0, 0, 0, 3531, 3532, 5, 393, 0, - 0, 3532, 3533, 5, 478, 0, 0, 3533, 417, 1, 0, 0, 0, 3534, 3535, 5, 33, - 0, 0, 3535, 3538, 3, 646, 323, 0, 3536, 3537, 5, 186, 0, 0, 3537, 3539, - 5, 478, 0, 0, 3538, 3536, 1, 0, 0, 0, 3538, 3539, 1, 0, 0, 0, 3539, 419, - 1, 0, 0, 0, 3540, 3541, 5, 343, 0, 0, 3541, 3542, 5, 342, 0, 0, 3542, 3544, - 3, 646, 323, 0, 3543, 3545, 3, 422, 211, 0, 3544, 3543, 1, 0, 0, 0, 3545, - 3546, 1, 0, 0, 0, 3546, 3544, 1, 0, 0, 0, 3546, 3547, 1, 0, 0, 0, 3547, - 3556, 1, 0, 0, 0, 3548, 3552, 5, 95, 0, 0, 3549, 3551, 3, 424, 212, 0, - 3550, 3549, 1, 0, 0, 0, 3551, 3554, 1, 0, 0, 0, 3552, 3550, 1, 0, 0, 0, - 3552, 3553, 1, 0, 0, 0, 3553, 3555, 1, 0, 0, 0, 3554, 3552, 1, 0, 0, 0, - 3555, 3557, 5, 82, 0, 0, 3556, 3548, 1, 0, 0, 0, 3556, 3557, 1, 0, 0, 0, - 3557, 421, 1, 0, 0, 0, 3558, 3559, 5, 404, 0, 0, 3559, 3586, 5, 478, 0, - 0, 3560, 3561, 5, 342, 0, 0, 3561, 3565, 5, 257, 0, 0, 3562, 3566, 5, 478, - 0, 0, 3563, 3564, 5, 471, 0, 0, 3564, 3566, 3, 646, 323, 0, 3565, 3562, - 1, 0, 0, 0, 3565, 3563, 1, 0, 0, 0, 3566, 3586, 1, 0, 0, 0, 3567, 3568, - 5, 62, 0, 0, 3568, 3586, 5, 478, 0, 0, 3569, 3570, 5, 63, 0, 0, 3570, 3586, - 5, 480, 0, 0, 3571, 3572, 5, 343, 0, 0, 3572, 3586, 5, 478, 0, 0, 3573, - 3577, 5, 340, 0, 0, 3574, 3578, 5, 478, 0, 0, 3575, 3576, 5, 471, 0, 0, - 3576, 3578, 3, 646, 323, 0, 3577, 3574, 1, 0, 0, 0, 3577, 3575, 1, 0, 0, - 0, 3578, 3586, 1, 0, 0, 0, 3579, 3583, 5, 341, 0, 0, 3580, 3584, 5, 478, - 0, 0, 3581, 3582, 5, 471, 0, 0, 3582, 3584, 3, 646, 323, 0, 3583, 3580, - 1, 0, 0, 0, 3583, 3581, 1, 0, 0, 0, 3584, 3586, 1, 0, 0, 0, 3585, 3558, - 1, 0, 0, 0, 3585, 3560, 1, 0, 0, 0, 3585, 3567, 1, 0, 0, 0, 3585, 3569, - 1, 0, 0, 0, 3585, 3571, 1, 0, 0, 0, 3585, 3573, 1, 0, 0, 0, 3585, 3579, - 1, 0, 0, 0, 3586, 423, 1, 0, 0, 0, 3587, 3588, 5, 344, 0, 0, 3588, 3589, - 3, 648, 324, 0, 3589, 3590, 5, 418, 0, 0, 3590, 3602, 7, 25, 0, 0, 3591, - 3592, 5, 358, 0, 0, 3592, 3593, 3, 648, 324, 0, 3593, 3594, 5, 470, 0, - 0, 3594, 3598, 3, 98, 49, 0, 3595, 3596, 5, 290, 0, 0, 3596, 3599, 5, 478, - 0, 0, 3597, 3599, 5, 283, 0, 0, 3598, 3595, 1, 0, 0, 0, 3598, 3597, 1, - 0, 0, 0, 3598, 3599, 1, 0, 0, 0, 3599, 3601, 1, 0, 0, 0, 3600, 3591, 1, - 0, 0, 0, 3601, 3604, 1, 0, 0, 0, 3602, 3600, 1, 0, 0, 0, 3602, 3603, 1, - 0, 0, 0, 3603, 3621, 1, 0, 0, 0, 3604, 3602, 1, 0, 0, 0, 3605, 3606, 5, - 76, 0, 0, 3606, 3619, 3, 646, 323, 0, 3607, 3608, 5, 345, 0, 0, 3608, 3609, - 5, 464, 0, 0, 3609, 3614, 3, 426, 213, 0, 3610, 3611, 5, 462, 0, 0, 3611, - 3613, 3, 426, 213, 0, 3612, 3610, 1, 0, 0, 0, 3613, 3616, 1, 0, 0, 0, 3614, - 3612, 1, 0, 0, 0, 3614, 3615, 1, 0, 0, 0, 3615, 3617, 1, 0, 0, 0, 3616, - 3614, 1, 0, 0, 0, 3617, 3618, 5, 465, 0, 0, 3618, 3620, 1, 0, 0, 0, 3619, - 3607, 1, 0, 0, 0, 3619, 3620, 1, 0, 0, 0, 3620, 3622, 1, 0, 0, 0, 3621, - 3605, 1, 0, 0, 0, 3621, 3622, 1, 0, 0, 0, 3622, 3623, 1, 0, 0, 0, 3623, - 3624, 5, 461, 0, 0, 3624, 425, 1, 0, 0, 0, 3625, 3626, 3, 648, 324, 0, - 3626, 3627, 5, 75, 0, 0, 3627, 3628, 3, 648, 324, 0, 3628, 427, 1, 0, 0, - 0, 3629, 3630, 5, 37, 0, 0, 3630, 3631, 3, 646, 323, 0, 3631, 3632, 5, - 404, 0, 0, 3632, 3633, 3, 98, 49, 0, 3633, 3634, 5, 290, 0, 0, 3634, 3636, - 3, 650, 325, 0, 3635, 3637, 3, 430, 215, 0, 3636, 3635, 1, 0, 0, 0, 3636, - 3637, 1, 0, 0, 0, 3637, 429, 1, 0, 0, 0, 3638, 3640, 3, 432, 216, 0, 3639, - 3638, 1, 0, 0, 0, 3640, 3641, 1, 0, 0, 0, 3641, 3639, 1, 0, 0, 0, 3641, - 3642, 1, 0, 0, 0, 3642, 431, 1, 0, 0, 0, 3643, 3644, 5, 393, 0, 0, 3644, - 3645, 5, 478, 0, 0, 3645, 433, 1, 0, 0, 0, 3646, 3647, 5, 305, 0, 0, 3647, - 3648, 5, 331, 0, 0, 3648, 3649, 3, 646, 323, 0, 3649, 3650, 3, 436, 218, - 0, 3650, 3654, 5, 95, 0, 0, 3651, 3653, 3, 442, 221, 0, 3652, 3651, 1, - 0, 0, 0, 3653, 3656, 1, 0, 0, 0, 3654, 3652, 1, 0, 0, 0, 3654, 3655, 1, - 0, 0, 0, 3655, 3657, 1, 0, 0, 0, 3656, 3654, 1, 0, 0, 0, 3657, 3658, 5, - 82, 0, 0, 3658, 435, 1, 0, 0, 0, 3659, 3661, 3, 438, 219, 0, 3660, 3659, - 1, 0, 0, 0, 3661, 3662, 1, 0, 0, 0, 3662, 3660, 1, 0, 0, 0, 3662, 3663, - 1, 0, 0, 0, 3663, 437, 1, 0, 0, 0, 3664, 3665, 5, 309, 0, 0, 3665, 3666, - 5, 214, 0, 0, 3666, 3674, 5, 478, 0, 0, 3667, 3668, 5, 318, 0, 0, 3668, - 3674, 5, 480, 0, 0, 3669, 3670, 5, 311, 0, 0, 3670, 3674, 3, 440, 220, - 0, 3671, 3672, 5, 393, 0, 0, 3672, 3674, 5, 478, 0, 0, 3673, 3664, 1, 0, - 0, 0, 3673, 3667, 1, 0, 0, 0, 3673, 3669, 1, 0, 0, 0, 3673, 3671, 1, 0, - 0, 0, 3674, 439, 1, 0, 0, 0, 3675, 3676, 5, 312, 0, 0, 3676, 3677, 5, 340, - 0, 0, 3677, 3678, 5, 478, 0, 0, 3678, 3679, 5, 341, 0, 0, 3679, 3684, 5, - 478, 0, 0, 3680, 3681, 5, 314, 0, 0, 3681, 3684, 5, 478, 0, 0, 3682, 3684, - 5, 408, 0, 0, 3683, 3675, 1, 0, 0, 0, 3683, 3680, 1, 0, 0, 0, 3683, 3682, - 1, 0, 0, 0, 3684, 441, 1, 0, 0, 0, 3685, 3686, 5, 315, 0, 0, 3686, 3687, - 5, 482, 0, 0, 3687, 3688, 5, 316, 0, 0, 3688, 3689, 3, 444, 222, 0, 3689, - 3690, 5, 317, 0, 0, 3690, 3692, 5, 478, 0, 0, 3691, 3693, 3, 446, 223, - 0, 3692, 3691, 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 443, 1, 0, 0, - 0, 3694, 3695, 7, 13, 0, 0, 3695, 445, 1, 0, 0, 0, 3696, 3698, 3, 448, - 224, 0, 3697, 3696, 1, 0, 0, 0, 3698, 3699, 1, 0, 0, 0, 3699, 3697, 1, - 0, 0, 0, 3699, 3700, 1, 0, 0, 0, 3700, 447, 1, 0, 0, 0, 3701, 3702, 5, - 319, 0, 0, 3702, 3710, 5, 478, 0, 0, 3703, 3704, 5, 320, 0, 0, 3704, 3710, - 3, 450, 225, 0, 3705, 3706, 5, 358, 0, 0, 3706, 3710, 3, 452, 226, 0, 3707, - 3708, 5, 318, 0, 0, 3708, 3710, 5, 480, 0, 0, 3709, 3701, 1, 0, 0, 0, 3709, - 3703, 1, 0, 0, 0, 3709, 3705, 1, 0, 0, 0, 3709, 3707, 1, 0, 0, 0, 3710, - 449, 1, 0, 0, 0, 3711, 3712, 5, 324, 0, 0, 3712, 3713, 5, 480, 0, 0, 3713, - 3714, 3, 98, 49, 0, 3714, 451, 1, 0, 0, 0, 3715, 3716, 5, 482, 0, 0, 3716, - 3717, 5, 470, 0, 0, 3717, 3720, 3, 98, 49, 0, 3718, 3719, 5, 284, 0, 0, - 3719, 3721, 7, 26, 0, 0, 3720, 3718, 1, 0, 0, 0, 3720, 3721, 1, 0, 0, 0, - 3721, 453, 1, 0, 0, 0, 3722, 3723, 5, 41, 0, 0, 3723, 3724, 5, 482, 0, - 0, 3724, 3725, 5, 92, 0, 0, 3725, 3726, 3, 646, 323, 0, 3726, 3727, 5, - 464, 0, 0, 3727, 3728, 3, 106, 53, 0, 3728, 3729, 5, 465, 0, 0, 3729, 455, - 1, 0, 0, 0, 3730, 3731, 5, 308, 0, 0, 3731, 3732, 5, 331, 0, 0, 3732, 3733, - 3, 646, 323, 0, 3733, 3734, 5, 464, 0, 0, 3734, 3739, 3, 462, 231, 0, 3735, - 3736, 5, 462, 0, 0, 3736, 3738, 3, 462, 231, 0, 3737, 3735, 1, 0, 0, 0, - 3738, 3741, 1, 0, 0, 0, 3739, 3737, 1, 0, 0, 0, 3739, 3740, 1, 0, 0, 0, - 3740, 3742, 1, 0, 0, 0, 3741, 3739, 1, 0, 0, 0, 3742, 3744, 5, 465, 0, - 0, 3743, 3745, 3, 482, 241, 0, 3744, 3743, 1, 0, 0, 0, 3744, 3745, 1, 0, - 0, 0, 3745, 457, 1, 0, 0, 0, 3746, 3747, 5, 308, 0, 0, 3747, 3748, 5, 306, - 0, 0, 3748, 3749, 3, 646, 323, 0, 3749, 3750, 5, 464, 0, 0, 3750, 3755, - 3, 462, 231, 0, 3751, 3752, 5, 462, 0, 0, 3752, 3754, 3, 462, 231, 0, 3753, - 3751, 1, 0, 0, 0, 3754, 3757, 1, 0, 0, 0, 3755, 3753, 1, 0, 0, 0, 3755, - 3756, 1, 0, 0, 0, 3756, 3758, 1, 0, 0, 0, 3757, 3755, 1, 0, 0, 0, 3758, - 3760, 5, 465, 0, 0, 3759, 3761, 3, 466, 233, 0, 3760, 3759, 1, 0, 0, 0, - 3760, 3761, 1, 0, 0, 0, 3761, 3770, 1, 0, 0, 0, 3762, 3766, 5, 466, 0, - 0, 3763, 3765, 3, 470, 235, 0, 3764, 3763, 1, 0, 0, 0, 3765, 3768, 1, 0, - 0, 0, 3766, 3764, 1, 0, 0, 0, 3766, 3767, 1, 0, 0, 0, 3767, 3769, 1, 0, - 0, 0, 3768, 3766, 1, 0, 0, 0, 3769, 3771, 5, 467, 0, 0, 3770, 3762, 1, - 0, 0, 0, 3770, 3771, 1, 0, 0, 0, 3771, 459, 1, 0, 0, 0, 3772, 3782, 5, - 478, 0, 0, 3773, 3782, 5, 480, 0, 0, 3774, 3782, 5, 291, 0, 0, 3775, 3782, - 5, 292, 0, 0, 3776, 3778, 5, 30, 0, 0, 3777, 3779, 3, 646, 323, 0, 3778, - 3777, 1, 0, 0, 0, 3778, 3779, 1, 0, 0, 0, 3779, 3782, 1, 0, 0, 0, 3780, - 3782, 3, 646, 323, 0, 3781, 3772, 1, 0, 0, 0, 3781, 3773, 1, 0, 0, 0, 3781, - 3774, 1, 0, 0, 0, 3781, 3775, 1, 0, 0, 0, 3781, 3776, 1, 0, 0, 0, 3781, - 3780, 1, 0, 0, 0, 3782, 461, 1, 0, 0, 0, 3783, 3784, 3, 648, 324, 0, 3784, - 3785, 5, 470, 0, 0, 3785, 3786, 3, 460, 230, 0, 3786, 463, 1, 0, 0, 0, - 3787, 3788, 3, 648, 324, 0, 3788, 3789, 5, 451, 0, 0, 3789, 3790, 3, 460, - 230, 0, 3790, 465, 1, 0, 0, 0, 3791, 3792, 5, 311, 0, 0, 3792, 3797, 3, - 468, 234, 0, 3793, 3794, 5, 462, 0, 0, 3794, 3796, 3, 468, 234, 0, 3795, - 3793, 1, 0, 0, 0, 3796, 3799, 1, 0, 0, 0, 3797, 3795, 1, 0, 0, 0, 3797, - 3798, 1, 0, 0, 0, 3798, 467, 1, 0, 0, 0, 3799, 3797, 1, 0, 0, 0, 3800, - 3809, 5, 312, 0, 0, 3801, 3809, 5, 336, 0, 0, 3802, 3809, 5, 337, 0, 0, - 3803, 3805, 5, 30, 0, 0, 3804, 3806, 3, 646, 323, 0, 3805, 3804, 1, 0, - 0, 0, 3805, 3806, 1, 0, 0, 0, 3806, 3809, 1, 0, 0, 0, 3807, 3809, 5, 482, - 0, 0, 3808, 3800, 1, 0, 0, 0, 3808, 3801, 1, 0, 0, 0, 3808, 3802, 1, 0, - 0, 0, 3808, 3803, 1, 0, 0, 0, 3808, 3807, 1, 0, 0, 0, 3809, 469, 1, 0, - 0, 0, 3810, 3811, 5, 333, 0, 0, 3811, 3812, 5, 23, 0, 0, 3812, 3815, 3, - 646, 323, 0, 3813, 3814, 5, 75, 0, 0, 3814, 3816, 5, 478, 0, 0, 3815, 3813, - 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, 3828, 1, 0, 0, 0, 3817, 3818, - 5, 464, 0, 0, 3818, 3823, 3, 462, 231, 0, 3819, 3820, 5, 462, 0, 0, 3820, - 3822, 3, 462, 231, 0, 3821, 3819, 1, 0, 0, 0, 3822, 3825, 1, 0, 0, 0, 3823, - 3821, 1, 0, 0, 0, 3823, 3824, 1, 0, 0, 0, 3824, 3826, 1, 0, 0, 0, 3825, - 3823, 1, 0, 0, 0, 3826, 3827, 5, 465, 0, 0, 3827, 3829, 1, 0, 0, 0, 3828, - 3817, 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, 3831, 1, 0, 0, 0, 3830, - 3832, 3, 472, 236, 0, 3831, 3830, 1, 0, 0, 0, 3831, 3832, 1, 0, 0, 0, 3832, - 3834, 1, 0, 0, 0, 3833, 3835, 5, 461, 0, 0, 3834, 3833, 1, 0, 0, 0, 3834, - 3835, 1, 0, 0, 0, 3835, 471, 1, 0, 0, 0, 3836, 3837, 5, 334, 0, 0, 3837, - 3847, 5, 464, 0, 0, 3838, 3848, 5, 456, 0, 0, 3839, 3844, 3, 474, 237, - 0, 3840, 3841, 5, 462, 0, 0, 3841, 3843, 3, 474, 237, 0, 3842, 3840, 1, - 0, 0, 0, 3843, 3846, 1, 0, 0, 0, 3844, 3842, 1, 0, 0, 0, 3844, 3845, 1, - 0, 0, 0, 3845, 3848, 1, 0, 0, 0, 3846, 3844, 1, 0, 0, 0, 3847, 3838, 1, - 0, 0, 0, 3847, 3839, 1, 0, 0, 0, 3848, 3849, 1, 0, 0, 0, 3849, 3850, 5, - 465, 0, 0, 3850, 473, 1, 0, 0, 0, 3851, 3854, 5, 482, 0, 0, 3852, 3853, - 5, 75, 0, 0, 3853, 3855, 5, 478, 0, 0, 3854, 3852, 1, 0, 0, 0, 3854, 3855, - 1, 0, 0, 0, 3855, 3857, 1, 0, 0, 0, 3856, 3858, 3, 476, 238, 0, 3857, 3856, - 1, 0, 0, 0, 3857, 3858, 1, 0, 0, 0, 3858, 475, 1, 0, 0, 0, 3859, 3860, - 5, 464, 0, 0, 3860, 3865, 5, 482, 0, 0, 3861, 3862, 5, 462, 0, 0, 3862, - 3864, 5, 482, 0, 0, 3863, 3861, 1, 0, 0, 0, 3864, 3867, 1, 0, 0, 0, 3865, - 3863, 1, 0, 0, 0, 3865, 3866, 1, 0, 0, 0, 3866, 3868, 1, 0, 0, 0, 3867, - 3865, 1, 0, 0, 0, 3868, 3869, 5, 465, 0, 0, 3869, 477, 1, 0, 0, 0, 3870, - 3871, 5, 26, 0, 0, 3871, 3872, 5, 23, 0, 0, 3872, 3873, 3, 646, 323, 0, - 3873, 3874, 5, 70, 0, 0, 3874, 3875, 5, 308, 0, 0, 3875, 3876, 5, 331, - 0, 0, 3876, 3877, 3, 646, 323, 0, 3877, 3878, 5, 464, 0, 0, 3878, 3883, - 3, 462, 231, 0, 3879, 3880, 5, 462, 0, 0, 3880, 3882, 3, 462, 231, 0, 3881, - 3879, 1, 0, 0, 0, 3882, 3885, 1, 0, 0, 0, 3883, 3881, 1, 0, 0, 0, 3883, - 3884, 1, 0, 0, 0, 3884, 3886, 1, 0, 0, 0, 3885, 3883, 1, 0, 0, 0, 3886, - 3892, 5, 465, 0, 0, 3887, 3889, 5, 464, 0, 0, 3888, 3890, 3, 90, 45, 0, - 3889, 3888, 1, 0, 0, 0, 3889, 3890, 1, 0, 0, 0, 3890, 3891, 1, 0, 0, 0, - 3891, 3893, 5, 465, 0, 0, 3892, 3887, 1, 0, 0, 0, 3892, 3893, 1, 0, 0, - 0, 3893, 479, 1, 0, 0, 0, 3894, 3897, 5, 361, 0, 0, 3895, 3898, 3, 646, - 323, 0, 3896, 3898, 5, 482, 0, 0, 3897, 3895, 1, 0, 0, 0, 3897, 3896, 1, - 0, 0, 0, 3898, 3902, 1, 0, 0, 0, 3899, 3901, 3, 28, 14, 0, 3900, 3899, - 1, 0, 0, 0, 3901, 3904, 1, 0, 0, 0, 3902, 3900, 1, 0, 0, 0, 3902, 3903, - 1, 0, 0, 0, 3903, 481, 1, 0, 0, 0, 3904, 3902, 1, 0, 0, 0, 3905, 3906, - 5, 360, 0, 0, 3906, 3907, 5, 464, 0, 0, 3907, 3912, 3, 484, 242, 0, 3908, - 3909, 5, 462, 0, 0, 3909, 3911, 3, 484, 242, 0, 3910, 3908, 1, 0, 0, 0, - 3911, 3914, 1, 0, 0, 0, 3912, 3910, 1, 0, 0, 0, 3912, 3913, 1, 0, 0, 0, - 3913, 3915, 1, 0, 0, 0, 3914, 3912, 1, 0, 0, 0, 3915, 3916, 5, 465, 0, - 0, 3916, 483, 1, 0, 0, 0, 3917, 3918, 5, 478, 0, 0, 3918, 3919, 5, 470, - 0, 0, 3919, 3920, 3, 460, 230, 0, 3920, 485, 1, 0, 0, 0, 3921, 3922, 5, - 424, 0, 0, 3922, 3923, 5, 425, 0, 0, 3923, 3924, 5, 306, 0, 0, 3924, 3925, - 3, 646, 323, 0, 3925, 3926, 5, 464, 0, 0, 3926, 3931, 3, 462, 231, 0, 3927, - 3928, 5, 462, 0, 0, 3928, 3930, 3, 462, 231, 0, 3929, 3927, 1, 0, 0, 0, - 3930, 3933, 1, 0, 0, 0, 3931, 3929, 1, 0, 0, 0, 3931, 3932, 1, 0, 0, 0, - 3932, 3934, 1, 0, 0, 0, 3933, 3931, 1, 0, 0, 0, 3934, 3935, 5, 465, 0, - 0, 3935, 3937, 5, 466, 0, 0, 3936, 3938, 3, 488, 244, 0, 3937, 3936, 1, - 0, 0, 0, 3938, 3939, 1, 0, 0, 0, 3939, 3937, 1, 0, 0, 0, 3939, 3940, 1, - 0, 0, 0, 3940, 3941, 1, 0, 0, 0, 3941, 3942, 5, 467, 0, 0, 3942, 487, 1, - 0, 0, 0, 3943, 3944, 5, 392, 0, 0, 3944, 3945, 5, 482, 0, 0, 3945, 3946, - 5, 464, 0, 0, 3946, 3951, 3, 490, 245, 0, 3947, 3948, 5, 462, 0, 0, 3948, - 3950, 3, 490, 245, 0, 3949, 3947, 1, 0, 0, 0, 3950, 3953, 1, 0, 0, 0, 3951, - 3949, 1, 0, 0, 0, 3951, 3952, 1, 0, 0, 0, 3952, 3954, 1, 0, 0, 0, 3953, - 3951, 1, 0, 0, 0, 3954, 3955, 5, 465, 0, 0, 3955, 3958, 7, 27, 0, 0, 3956, - 3957, 5, 23, 0, 0, 3957, 3959, 3, 646, 323, 0, 3958, 3956, 1, 0, 0, 0, - 3958, 3959, 1, 0, 0, 0, 3959, 3962, 1, 0, 0, 0, 3960, 3961, 5, 30, 0, 0, - 3961, 3963, 3, 646, 323, 0, 3962, 3960, 1, 0, 0, 0, 3962, 3963, 1, 0, 0, - 0, 3963, 3964, 1, 0, 0, 0, 3964, 3965, 5, 461, 0, 0, 3965, 489, 1, 0, 0, - 0, 3966, 3967, 5, 482, 0, 0, 3967, 3968, 5, 470, 0, 0, 3968, 3969, 3, 98, - 49, 0, 3969, 491, 1, 0, 0, 0, 3970, 3971, 3, 494, 247, 0, 3971, 3976, 3, - 496, 248, 0, 3972, 3973, 5, 462, 0, 0, 3973, 3975, 3, 496, 248, 0, 3974, - 3972, 1, 0, 0, 0, 3975, 3978, 1, 0, 0, 0, 3976, 3974, 1, 0, 0, 0, 3976, - 3977, 1, 0, 0, 0, 3977, 3999, 1, 0, 0, 0, 3978, 3976, 1, 0, 0, 0, 3979, - 3980, 5, 37, 0, 0, 3980, 3981, 5, 478, 0, 0, 3981, 3982, 5, 405, 0, 0, - 3982, 3986, 3, 498, 249, 0, 3983, 3984, 5, 284, 0, 0, 3984, 3985, 5, 428, - 0, 0, 3985, 3987, 5, 478, 0, 0, 3986, 3983, 1, 0, 0, 0, 3986, 3987, 1, - 0, 0, 0, 3987, 3999, 1, 0, 0, 0, 3988, 3989, 5, 428, 0, 0, 3989, 3990, - 5, 478, 0, 0, 3990, 3995, 3, 496, 248, 0, 3991, 3992, 5, 462, 0, 0, 3992, - 3994, 3, 496, 248, 0, 3993, 3991, 1, 0, 0, 0, 3994, 3997, 1, 0, 0, 0, 3995, - 3993, 1, 0, 0, 0, 3995, 3996, 1, 0, 0, 0, 3996, 3999, 1, 0, 0, 0, 3997, - 3995, 1, 0, 0, 0, 3998, 3970, 1, 0, 0, 0, 3998, 3979, 1, 0, 0, 0, 3998, - 3988, 1, 0, 0, 0, 3999, 493, 1, 0, 0, 0, 4000, 4001, 7, 28, 0, 0, 4001, - 495, 1, 0, 0, 0, 4002, 4003, 5, 482, 0, 0, 4003, 4004, 5, 451, 0, 0, 4004, - 4005, 3, 498, 249, 0, 4005, 497, 1, 0, 0, 0, 4006, 4011, 5, 478, 0, 0, - 4007, 4011, 5, 480, 0, 0, 4008, 4011, 3, 654, 327, 0, 4009, 4011, 3, 646, - 323, 0, 4010, 4006, 1, 0, 0, 0, 4010, 4007, 1, 0, 0, 0, 4010, 4008, 1, - 0, 0, 0, 4010, 4009, 1, 0, 0, 0, 4011, 499, 1, 0, 0, 0, 4012, 4017, 3, - 502, 251, 0, 4013, 4017, 3, 514, 257, 0, 4014, 4017, 3, 516, 258, 0, 4015, - 4017, 3, 522, 261, 0, 4016, 4012, 1, 0, 0, 0, 4016, 4013, 1, 0, 0, 0, 4016, - 4014, 1, 0, 0, 0, 4016, 4015, 1, 0, 0, 0, 4017, 501, 1, 0, 0, 0, 4018, - 4019, 5, 64, 0, 0, 4019, 4340, 5, 367, 0, 0, 4020, 4021, 5, 64, 0, 0, 4021, - 4027, 5, 368, 0, 0, 4022, 4025, 5, 284, 0, 0, 4023, 4026, 3, 646, 323, - 0, 4024, 4026, 5, 482, 0, 0, 4025, 4023, 1, 0, 0, 0, 4025, 4024, 1, 0, - 0, 0, 4026, 4028, 1, 0, 0, 0, 4027, 4022, 1, 0, 0, 0, 4027, 4028, 1, 0, - 0, 0, 4028, 4340, 1, 0, 0, 0, 4029, 4030, 5, 64, 0, 0, 4030, 4036, 5, 369, - 0, 0, 4031, 4034, 5, 284, 0, 0, 4032, 4035, 3, 646, 323, 0, 4033, 4035, - 5, 482, 0, 0, 4034, 4032, 1, 0, 0, 0, 4034, 4033, 1, 0, 0, 0, 4035, 4037, - 1, 0, 0, 0, 4036, 4031, 1, 0, 0, 0, 4036, 4037, 1, 0, 0, 0, 4037, 4340, - 1, 0, 0, 0, 4038, 4039, 5, 64, 0, 0, 4039, 4045, 5, 370, 0, 0, 4040, 4043, - 5, 284, 0, 0, 4041, 4044, 3, 646, 323, 0, 4042, 4044, 5, 482, 0, 0, 4043, - 4041, 1, 0, 0, 0, 4043, 4042, 1, 0, 0, 0, 4044, 4046, 1, 0, 0, 0, 4045, - 4040, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4340, 1, 0, 0, 0, 4047, - 4048, 5, 64, 0, 0, 4048, 4054, 5, 371, 0, 0, 4049, 4052, 5, 284, 0, 0, - 4050, 4053, 3, 646, 323, 0, 4051, 4053, 5, 482, 0, 0, 4052, 4050, 1, 0, - 0, 0, 4052, 4051, 1, 0, 0, 0, 4053, 4055, 1, 0, 0, 0, 4054, 4049, 1, 0, - 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, 4340, 1, 0, 0, 0, 4056, 4057, 5, 64, - 0, 0, 4057, 4063, 5, 372, 0, 0, 4058, 4061, 5, 284, 0, 0, 4059, 4062, 3, - 646, 323, 0, 4060, 4062, 5, 482, 0, 0, 4061, 4059, 1, 0, 0, 0, 4061, 4060, - 1, 0, 0, 0, 4062, 4064, 1, 0, 0, 0, 4063, 4058, 1, 0, 0, 0, 4063, 4064, - 1, 0, 0, 0, 4064, 4340, 1, 0, 0, 0, 4065, 4066, 5, 64, 0, 0, 4066, 4072, - 5, 141, 0, 0, 4067, 4070, 5, 284, 0, 0, 4068, 4071, 3, 646, 323, 0, 4069, - 4071, 5, 482, 0, 0, 4070, 4068, 1, 0, 0, 0, 4070, 4069, 1, 0, 0, 0, 4071, - 4073, 1, 0, 0, 0, 4072, 4067, 1, 0, 0, 0, 4072, 4073, 1, 0, 0, 0, 4073, - 4340, 1, 0, 0, 0, 4074, 4075, 5, 64, 0, 0, 4075, 4081, 5, 143, 0, 0, 4076, - 4079, 5, 284, 0, 0, 4077, 4080, 3, 646, 323, 0, 4078, 4080, 5, 482, 0, - 0, 4079, 4077, 1, 0, 0, 0, 4079, 4078, 1, 0, 0, 0, 4080, 4082, 1, 0, 0, - 0, 4081, 4076, 1, 0, 0, 0, 4081, 4082, 1, 0, 0, 0, 4082, 4340, 1, 0, 0, - 0, 4083, 4084, 5, 64, 0, 0, 4084, 4090, 5, 373, 0, 0, 4085, 4088, 5, 284, - 0, 0, 4086, 4089, 3, 646, 323, 0, 4087, 4089, 5, 482, 0, 0, 4088, 4086, - 1, 0, 0, 0, 4088, 4087, 1, 0, 0, 0, 4089, 4091, 1, 0, 0, 0, 4090, 4085, - 1, 0, 0, 0, 4090, 4091, 1, 0, 0, 0, 4091, 4340, 1, 0, 0, 0, 4092, 4093, - 5, 64, 0, 0, 4093, 4099, 5, 374, 0, 0, 4094, 4097, 5, 284, 0, 0, 4095, - 4098, 3, 646, 323, 0, 4096, 4098, 5, 482, 0, 0, 4097, 4095, 1, 0, 0, 0, - 4097, 4096, 1, 0, 0, 0, 4098, 4100, 1, 0, 0, 0, 4099, 4094, 1, 0, 0, 0, - 4099, 4100, 1, 0, 0, 0, 4100, 4340, 1, 0, 0, 0, 4101, 4102, 5, 64, 0, 0, - 4102, 4108, 5, 142, 0, 0, 4103, 4106, 5, 284, 0, 0, 4104, 4107, 3, 646, - 323, 0, 4105, 4107, 5, 482, 0, 0, 4106, 4104, 1, 0, 0, 0, 4106, 4105, 1, - 0, 0, 0, 4107, 4109, 1, 0, 0, 0, 4108, 4103, 1, 0, 0, 0, 4108, 4109, 1, - 0, 0, 0, 4109, 4340, 1, 0, 0, 0, 4110, 4111, 5, 64, 0, 0, 4111, 4117, 5, - 144, 0, 0, 4112, 4115, 5, 284, 0, 0, 4113, 4116, 3, 646, 323, 0, 4114, - 4116, 5, 482, 0, 0, 4115, 4113, 1, 0, 0, 0, 4115, 4114, 1, 0, 0, 0, 4116, - 4118, 1, 0, 0, 0, 4117, 4112, 1, 0, 0, 0, 4117, 4118, 1, 0, 0, 0, 4118, - 4340, 1, 0, 0, 0, 4119, 4120, 5, 64, 0, 0, 4120, 4121, 5, 113, 0, 0, 4121, - 4127, 5, 115, 0, 0, 4122, 4125, 5, 284, 0, 0, 4123, 4126, 3, 646, 323, - 0, 4124, 4126, 5, 482, 0, 0, 4125, 4123, 1, 0, 0, 0, 4125, 4124, 1, 0, - 0, 0, 4126, 4128, 1, 0, 0, 0, 4127, 4122, 1, 0, 0, 0, 4127, 4128, 1, 0, - 0, 0, 4128, 4340, 1, 0, 0, 0, 4129, 4130, 5, 64, 0, 0, 4130, 4131, 5, 23, - 0, 0, 4131, 4340, 3, 646, 323, 0, 4132, 4133, 5, 64, 0, 0, 4133, 4134, - 5, 27, 0, 0, 4134, 4340, 3, 646, 323, 0, 4135, 4136, 5, 64, 0, 0, 4136, - 4137, 5, 33, 0, 0, 4137, 4340, 3, 646, 323, 0, 4138, 4139, 5, 64, 0, 0, - 4139, 4340, 5, 375, 0, 0, 4140, 4141, 5, 64, 0, 0, 4141, 4340, 5, 324, - 0, 0, 4142, 4143, 5, 64, 0, 0, 4143, 4340, 5, 325, 0, 0, 4144, 4145, 5, - 64, 0, 0, 4145, 4146, 5, 394, 0, 0, 4146, 4340, 5, 324, 0, 0, 4147, 4148, - 5, 64, 0, 0, 4148, 4149, 5, 394, 0, 0, 4149, 4340, 5, 355, 0, 0, 4150, - 4151, 5, 64, 0, 0, 4151, 4152, 5, 397, 0, 0, 4152, 4153, 5, 411, 0, 0, - 4153, 4155, 3, 646, 323, 0, 4154, 4156, 5, 400, 0, 0, 4155, 4154, 1, 0, - 0, 0, 4155, 4156, 1, 0, 0, 0, 4156, 4340, 1, 0, 0, 0, 4157, 4158, 5, 64, - 0, 0, 4158, 4159, 5, 398, 0, 0, 4159, 4160, 5, 411, 0, 0, 4160, 4162, 3, - 646, 323, 0, 4161, 4163, 5, 400, 0, 0, 4162, 4161, 1, 0, 0, 0, 4162, 4163, - 1, 0, 0, 0, 4163, 4340, 1, 0, 0, 0, 4164, 4165, 5, 64, 0, 0, 4165, 4166, - 5, 399, 0, 0, 4166, 4167, 5, 410, 0, 0, 4167, 4340, 3, 646, 323, 0, 4168, - 4169, 5, 64, 0, 0, 4169, 4170, 5, 401, 0, 0, 4170, 4171, 5, 411, 0, 0, - 4171, 4340, 3, 646, 323, 0, 4172, 4173, 5, 64, 0, 0, 4173, 4174, 5, 217, - 0, 0, 4174, 4175, 5, 411, 0, 0, 4175, 4178, 3, 646, 323, 0, 4176, 4177, - 5, 402, 0, 0, 4177, 4179, 5, 480, 0, 0, 4178, 4176, 1, 0, 0, 0, 4178, 4179, - 1, 0, 0, 0, 4179, 4340, 1, 0, 0, 0, 4180, 4181, 5, 64, 0, 0, 4181, 4183, - 5, 185, 0, 0, 4182, 4184, 3, 504, 252, 0, 4183, 4182, 1, 0, 0, 0, 4183, - 4184, 1, 0, 0, 0, 4184, 4340, 1, 0, 0, 0, 4185, 4186, 5, 64, 0, 0, 4186, - 4187, 5, 58, 0, 0, 4187, 4340, 5, 429, 0, 0, 4188, 4189, 5, 64, 0, 0, 4189, - 4190, 5, 29, 0, 0, 4190, 4196, 5, 431, 0, 0, 4191, 4194, 5, 284, 0, 0, - 4192, 4195, 3, 646, 323, 0, 4193, 4195, 5, 482, 0, 0, 4194, 4192, 1, 0, - 0, 0, 4194, 4193, 1, 0, 0, 0, 4195, 4197, 1, 0, 0, 0, 4196, 4191, 1, 0, - 0, 0, 4196, 4197, 1, 0, 0, 0, 4197, 4340, 1, 0, 0, 0, 4198, 4199, 5, 64, - 0, 0, 4199, 4200, 5, 442, 0, 0, 4200, 4340, 5, 431, 0, 0, 4201, 4202, 5, - 64, 0, 0, 4202, 4203, 5, 437, 0, 0, 4203, 4340, 5, 447, 0, 0, 4204, 4205, - 5, 64, 0, 0, 4205, 4206, 5, 440, 0, 0, 4206, 4207, 5, 92, 0, 0, 4207, 4340, - 3, 646, 323, 0, 4208, 4209, 5, 64, 0, 0, 4209, 4210, 5, 440, 0, 0, 4210, - 4211, 5, 92, 0, 0, 4211, 4212, 5, 30, 0, 0, 4212, 4340, 3, 646, 323, 0, - 4213, 4214, 5, 64, 0, 0, 4214, 4215, 5, 440, 0, 0, 4215, 4216, 5, 92, 0, - 0, 4216, 4217, 5, 33, 0, 0, 4217, 4340, 3, 646, 323, 0, 4218, 4219, 5, - 64, 0, 0, 4219, 4220, 5, 429, 0, 0, 4220, 4226, 5, 438, 0, 0, 4221, 4224, - 5, 284, 0, 0, 4222, 4225, 3, 646, 323, 0, 4223, 4225, 5, 482, 0, 0, 4224, - 4222, 1, 0, 0, 0, 4224, 4223, 1, 0, 0, 0, 4225, 4227, 1, 0, 0, 0, 4226, - 4221, 1, 0, 0, 0, 4226, 4227, 1, 0, 0, 0, 4227, 4340, 1, 0, 0, 0, 4228, - 4229, 5, 64, 0, 0, 4229, 4230, 5, 308, 0, 0, 4230, 4236, 5, 332, 0, 0, - 4231, 4234, 5, 284, 0, 0, 4232, 4235, 3, 646, 323, 0, 4233, 4235, 5, 482, - 0, 0, 4234, 4232, 1, 0, 0, 0, 4234, 4233, 1, 0, 0, 0, 4235, 4237, 1, 0, - 0, 0, 4236, 4231, 1, 0, 0, 0, 4236, 4237, 1, 0, 0, 0, 4237, 4340, 1, 0, - 0, 0, 4238, 4239, 5, 64, 0, 0, 4239, 4240, 5, 308, 0, 0, 4240, 4246, 5, - 307, 0, 0, 4241, 4244, 5, 284, 0, 0, 4242, 4245, 3, 646, 323, 0, 4243, - 4245, 5, 482, 0, 0, 4244, 4242, 1, 0, 0, 0, 4244, 4243, 1, 0, 0, 0, 4245, - 4247, 1, 0, 0, 0, 4246, 4241, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, - 4340, 1, 0, 0, 0, 4248, 4249, 5, 64, 0, 0, 4249, 4250, 5, 26, 0, 0, 4250, - 4256, 5, 368, 0, 0, 4251, 4254, 5, 284, 0, 0, 4252, 4255, 3, 646, 323, - 0, 4253, 4255, 5, 482, 0, 0, 4254, 4252, 1, 0, 0, 0, 4254, 4253, 1, 0, - 0, 0, 4255, 4257, 1, 0, 0, 0, 4256, 4251, 1, 0, 0, 0, 4256, 4257, 1, 0, - 0, 0, 4257, 4340, 1, 0, 0, 0, 4258, 4259, 5, 64, 0, 0, 4259, 4340, 5, 361, - 0, 0, 4260, 4261, 5, 64, 0, 0, 4261, 4262, 5, 361, 0, 0, 4262, 4265, 5, - 362, 0, 0, 4263, 4266, 3, 646, 323, 0, 4264, 4266, 5, 482, 0, 0, 4265, - 4263, 1, 0, 0, 0, 4265, 4264, 1, 0, 0, 0, 4265, 4266, 1, 0, 0, 0, 4266, - 4340, 1, 0, 0, 0, 4267, 4268, 5, 64, 0, 0, 4268, 4269, 5, 361, 0, 0, 4269, - 4340, 5, 363, 0, 0, 4270, 4271, 5, 64, 0, 0, 4271, 4272, 5, 206, 0, 0, - 4272, 4275, 5, 207, 0, 0, 4273, 4274, 5, 413, 0, 0, 4274, 4276, 3, 506, - 253, 0, 4275, 4273, 1, 0, 0, 0, 4275, 4276, 1, 0, 0, 0, 4276, 4340, 1, - 0, 0, 0, 4277, 4278, 5, 64, 0, 0, 4278, 4281, 5, 403, 0, 0, 4279, 4280, - 5, 402, 0, 0, 4280, 4282, 5, 480, 0, 0, 4281, 4279, 1, 0, 0, 0, 4281, 4282, - 1, 0, 0, 0, 4282, 4288, 1, 0, 0, 0, 4283, 4286, 5, 284, 0, 0, 4284, 4287, - 3, 646, 323, 0, 4285, 4287, 5, 482, 0, 0, 4286, 4284, 1, 0, 0, 0, 4286, - 4285, 1, 0, 0, 0, 4287, 4289, 1, 0, 0, 0, 4288, 4283, 1, 0, 0, 0, 4288, - 4289, 1, 0, 0, 0, 4289, 4291, 1, 0, 0, 0, 4290, 4292, 5, 84, 0, 0, 4291, - 4290, 1, 0, 0, 0, 4291, 4292, 1, 0, 0, 0, 4292, 4340, 1, 0, 0, 0, 4293, - 4294, 5, 64, 0, 0, 4294, 4295, 5, 424, 0, 0, 4295, 4296, 5, 425, 0, 0, - 4296, 4302, 5, 307, 0, 0, 4297, 4300, 5, 284, 0, 0, 4298, 4301, 3, 646, - 323, 0, 4299, 4301, 5, 482, 0, 0, 4300, 4298, 1, 0, 0, 0, 4300, 4299, 1, - 0, 0, 0, 4301, 4303, 1, 0, 0, 0, 4302, 4297, 1, 0, 0, 0, 4302, 4303, 1, - 0, 0, 0, 4303, 4340, 1, 0, 0, 0, 4304, 4305, 5, 64, 0, 0, 4305, 4306, 5, - 424, 0, 0, 4306, 4307, 5, 425, 0, 0, 4307, 4313, 5, 332, 0, 0, 4308, 4311, - 5, 284, 0, 0, 4309, 4312, 3, 646, 323, 0, 4310, 4312, 5, 482, 0, 0, 4311, - 4309, 1, 0, 0, 0, 4311, 4310, 1, 0, 0, 0, 4312, 4314, 1, 0, 0, 0, 4313, - 4308, 1, 0, 0, 0, 4313, 4314, 1, 0, 0, 0, 4314, 4340, 1, 0, 0, 0, 4315, - 4316, 5, 64, 0, 0, 4316, 4317, 5, 424, 0, 0, 4317, 4323, 5, 118, 0, 0, - 4318, 4321, 5, 284, 0, 0, 4319, 4322, 3, 646, 323, 0, 4320, 4322, 5, 482, - 0, 0, 4321, 4319, 1, 0, 0, 0, 4321, 4320, 1, 0, 0, 0, 4322, 4324, 1, 0, - 0, 0, 4323, 4318, 1, 0, 0, 0, 4323, 4324, 1, 0, 0, 0, 4324, 4340, 1, 0, - 0, 0, 4325, 4326, 5, 64, 0, 0, 4326, 4340, 5, 427, 0, 0, 4327, 4328, 5, - 64, 0, 0, 4328, 4340, 5, 378, 0, 0, 4329, 4330, 5, 64, 0, 0, 4330, 4331, - 5, 343, 0, 0, 4331, 4337, 5, 375, 0, 0, 4332, 4335, 5, 284, 0, 0, 4333, - 4336, 3, 646, 323, 0, 4334, 4336, 5, 482, 0, 0, 4335, 4333, 1, 0, 0, 0, - 4335, 4334, 1, 0, 0, 0, 4336, 4338, 1, 0, 0, 0, 4337, 4332, 1, 0, 0, 0, - 4337, 4338, 1, 0, 0, 0, 4338, 4340, 1, 0, 0, 0, 4339, 4018, 1, 0, 0, 0, - 4339, 4020, 1, 0, 0, 0, 4339, 4029, 1, 0, 0, 0, 4339, 4038, 1, 0, 0, 0, - 4339, 4047, 1, 0, 0, 0, 4339, 4056, 1, 0, 0, 0, 4339, 4065, 1, 0, 0, 0, - 4339, 4074, 1, 0, 0, 0, 4339, 4083, 1, 0, 0, 0, 4339, 4092, 1, 0, 0, 0, - 4339, 4101, 1, 0, 0, 0, 4339, 4110, 1, 0, 0, 0, 4339, 4119, 1, 0, 0, 0, - 4339, 4129, 1, 0, 0, 0, 4339, 4132, 1, 0, 0, 0, 4339, 4135, 1, 0, 0, 0, - 4339, 4138, 1, 0, 0, 0, 4339, 4140, 1, 0, 0, 0, 4339, 4142, 1, 0, 0, 0, - 4339, 4144, 1, 0, 0, 0, 4339, 4147, 1, 0, 0, 0, 4339, 4150, 1, 0, 0, 0, - 4339, 4157, 1, 0, 0, 0, 4339, 4164, 1, 0, 0, 0, 4339, 4168, 1, 0, 0, 0, - 4339, 4172, 1, 0, 0, 0, 4339, 4180, 1, 0, 0, 0, 4339, 4185, 1, 0, 0, 0, - 4339, 4188, 1, 0, 0, 0, 4339, 4198, 1, 0, 0, 0, 4339, 4201, 1, 0, 0, 0, - 4339, 4204, 1, 0, 0, 0, 4339, 4208, 1, 0, 0, 0, 4339, 4213, 1, 0, 0, 0, - 4339, 4218, 1, 0, 0, 0, 4339, 4228, 1, 0, 0, 0, 4339, 4238, 1, 0, 0, 0, - 4339, 4248, 1, 0, 0, 0, 4339, 4258, 1, 0, 0, 0, 4339, 4260, 1, 0, 0, 0, - 4339, 4267, 1, 0, 0, 0, 4339, 4270, 1, 0, 0, 0, 4339, 4277, 1, 0, 0, 0, - 4339, 4293, 1, 0, 0, 0, 4339, 4304, 1, 0, 0, 0, 4339, 4315, 1, 0, 0, 0, - 4339, 4325, 1, 0, 0, 0, 4339, 4327, 1, 0, 0, 0, 4339, 4329, 1, 0, 0, 0, - 4340, 503, 1, 0, 0, 0, 4341, 4342, 5, 71, 0, 0, 4342, 4347, 3, 508, 254, - 0, 4343, 4344, 5, 280, 0, 0, 4344, 4346, 3, 508, 254, 0, 4345, 4343, 1, - 0, 0, 0, 4346, 4349, 1, 0, 0, 0, 4347, 4345, 1, 0, 0, 0, 4347, 4348, 1, - 0, 0, 0, 4348, 4355, 1, 0, 0, 0, 4349, 4347, 1, 0, 0, 0, 4350, 4353, 5, - 284, 0, 0, 4351, 4354, 3, 646, 323, 0, 4352, 4354, 5, 482, 0, 0, 4353, - 4351, 1, 0, 0, 0, 4353, 4352, 1, 0, 0, 0, 4354, 4356, 1, 0, 0, 0, 4355, - 4350, 1, 0, 0, 0, 4355, 4356, 1, 0, 0, 0, 4356, 4363, 1, 0, 0, 0, 4357, - 4360, 5, 284, 0, 0, 4358, 4361, 3, 646, 323, 0, 4359, 4361, 5, 482, 0, - 0, 4360, 4358, 1, 0, 0, 0, 4360, 4359, 1, 0, 0, 0, 4361, 4363, 1, 0, 0, - 0, 4362, 4341, 1, 0, 0, 0, 4362, 4357, 1, 0, 0, 0, 4363, 505, 1, 0, 0, - 0, 4364, 4365, 7, 29, 0, 0, 4365, 507, 1, 0, 0, 0, 4366, 4367, 5, 422, - 0, 0, 4367, 4368, 7, 30, 0, 0, 4368, 4373, 5, 478, 0, 0, 4369, 4370, 5, - 482, 0, 0, 4370, 4371, 7, 30, 0, 0, 4371, 4373, 5, 478, 0, 0, 4372, 4366, - 1, 0, 0, 0, 4372, 4369, 1, 0, 0, 0, 4373, 509, 1, 0, 0, 0, 4374, 4375, - 5, 478, 0, 0, 4375, 4376, 5, 451, 0, 0, 4376, 4377, 3, 512, 256, 0, 4377, - 511, 1, 0, 0, 0, 4378, 4383, 5, 478, 0, 0, 4379, 4383, 5, 480, 0, 0, 4380, - 4383, 3, 654, 327, 0, 4381, 4383, 5, 283, 0, 0, 4382, 4378, 1, 0, 0, 0, - 4382, 4379, 1, 0, 0, 0, 4382, 4380, 1, 0, 0, 0, 4382, 4381, 1, 0, 0, 0, - 4383, 513, 1, 0, 0, 0, 4384, 4385, 5, 65, 0, 0, 4385, 4386, 5, 23, 0, 0, - 4386, 4499, 3, 646, 323, 0, 4387, 4388, 5, 65, 0, 0, 4388, 4389, 5, 27, - 0, 0, 4389, 4499, 3, 646, 323, 0, 4390, 4391, 5, 65, 0, 0, 4391, 4392, - 5, 30, 0, 0, 4392, 4499, 3, 646, 323, 0, 4393, 4394, 5, 65, 0, 0, 4394, - 4395, 5, 31, 0, 0, 4395, 4499, 3, 646, 323, 0, 4396, 4397, 5, 65, 0, 0, - 4397, 4398, 5, 32, 0, 0, 4398, 4499, 3, 646, 323, 0, 4399, 4400, 5, 65, - 0, 0, 4400, 4401, 5, 33, 0, 0, 4401, 4499, 3, 646, 323, 0, 4402, 4403, - 5, 65, 0, 0, 4403, 4404, 5, 34, 0, 0, 4404, 4499, 3, 646, 323, 0, 4405, - 4406, 5, 65, 0, 0, 4406, 4407, 5, 35, 0, 0, 4407, 4499, 3, 646, 323, 0, - 4408, 4409, 5, 65, 0, 0, 4409, 4410, 5, 28, 0, 0, 4410, 4499, 3, 646, 323, - 0, 4411, 4412, 5, 65, 0, 0, 4412, 4413, 5, 37, 0, 0, 4413, 4499, 3, 646, - 323, 0, 4414, 4415, 5, 65, 0, 0, 4415, 4416, 5, 113, 0, 0, 4416, 4417, - 5, 114, 0, 0, 4417, 4499, 3, 646, 323, 0, 4418, 4419, 5, 65, 0, 0, 4419, - 4420, 5, 29, 0, 0, 4420, 4423, 5, 482, 0, 0, 4421, 4422, 5, 137, 0, 0, - 4422, 4424, 5, 84, 0, 0, 4423, 4421, 1, 0, 0, 0, 4423, 4424, 1, 0, 0, 0, - 4424, 4499, 1, 0, 0, 0, 4425, 4426, 5, 65, 0, 0, 4426, 4427, 5, 29, 0, - 0, 4427, 4428, 5, 430, 0, 0, 4428, 4499, 3, 646, 323, 0, 4429, 4430, 5, - 65, 0, 0, 4430, 4431, 5, 442, 0, 0, 4431, 4432, 5, 430, 0, 0, 4432, 4499, - 5, 478, 0, 0, 4433, 4434, 5, 65, 0, 0, 4434, 4435, 5, 437, 0, 0, 4435, - 4436, 5, 442, 0, 0, 4436, 4499, 5, 478, 0, 0, 4437, 4438, 5, 65, 0, 0, - 4438, 4439, 5, 308, 0, 0, 4439, 4440, 5, 331, 0, 0, 4440, 4499, 3, 646, - 323, 0, 4441, 4442, 5, 65, 0, 0, 4442, 4443, 5, 308, 0, 0, 4443, 4444, - 5, 306, 0, 0, 4444, 4499, 3, 646, 323, 0, 4445, 4446, 5, 65, 0, 0, 4446, - 4447, 5, 26, 0, 0, 4447, 4448, 5, 23, 0, 0, 4448, 4499, 3, 646, 323, 0, - 4449, 4450, 5, 65, 0, 0, 4450, 4453, 5, 361, 0, 0, 4451, 4454, 3, 646, - 323, 0, 4452, 4454, 5, 482, 0, 0, 4453, 4451, 1, 0, 0, 0, 4453, 4452, 1, - 0, 0, 0, 4453, 4454, 1, 0, 0, 0, 4454, 4499, 1, 0, 0, 0, 4455, 4456, 5, - 65, 0, 0, 4456, 4457, 5, 209, 0, 0, 4457, 4458, 5, 92, 0, 0, 4458, 4459, - 7, 1, 0, 0, 4459, 4462, 3, 646, 323, 0, 4460, 4461, 5, 184, 0, 0, 4461, - 4463, 5, 482, 0, 0, 4462, 4460, 1, 0, 0, 0, 4462, 4463, 1, 0, 0, 0, 4463, - 4499, 1, 0, 0, 0, 4464, 4465, 5, 65, 0, 0, 4465, 4466, 5, 394, 0, 0, 4466, - 4467, 5, 463, 0, 0, 4467, 4499, 3, 520, 260, 0, 4468, 4469, 5, 65, 0, 0, - 4469, 4470, 5, 424, 0, 0, 4470, 4471, 5, 425, 0, 0, 4471, 4472, 5, 306, - 0, 0, 4472, 4499, 3, 646, 323, 0, 4473, 4474, 5, 65, 0, 0, 4474, 4475, - 5, 343, 0, 0, 4475, 4476, 5, 342, 0, 0, 4476, 4499, 3, 646, 323, 0, 4477, - 4478, 5, 65, 0, 0, 4478, 4499, 5, 427, 0, 0, 4479, 4480, 5, 65, 0, 0, 4480, - 4481, 5, 377, 0, 0, 4481, 4482, 5, 70, 0, 0, 4482, 4483, 5, 33, 0, 0, 4483, - 4484, 3, 646, 323, 0, 4484, 4485, 5, 184, 0, 0, 4485, 4486, 3, 648, 324, - 0, 4486, 4499, 1, 0, 0, 0, 4487, 4488, 5, 65, 0, 0, 4488, 4489, 5, 377, - 0, 0, 4489, 4490, 5, 70, 0, 0, 4490, 4491, 5, 34, 0, 0, 4491, 4492, 3, - 646, 323, 0, 4492, 4493, 5, 184, 0, 0, 4493, 4494, 3, 648, 324, 0, 4494, - 4499, 1, 0, 0, 0, 4495, 4496, 5, 65, 0, 0, 4496, 4497, 5, 377, 0, 0, 4497, - 4499, 3, 648, 324, 0, 4498, 4384, 1, 0, 0, 0, 4498, 4387, 1, 0, 0, 0, 4498, - 4390, 1, 0, 0, 0, 4498, 4393, 1, 0, 0, 0, 4498, 4396, 1, 0, 0, 0, 4498, - 4399, 1, 0, 0, 0, 4498, 4402, 1, 0, 0, 0, 4498, 4405, 1, 0, 0, 0, 4498, - 4408, 1, 0, 0, 0, 4498, 4411, 1, 0, 0, 0, 4498, 4414, 1, 0, 0, 0, 4498, - 4418, 1, 0, 0, 0, 4498, 4425, 1, 0, 0, 0, 4498, 4429, 1, 0, 0, 0, 4498, - 4433, 1, 0, 0, 0, 4498, 4437, 1, 0, 0, 0, 4498, 4441, 1, 0, 0, 0, 4498, - 4445, 1, 0, 0, 0, 4498, 4449, 1, 0, 0, 0, 4498, 4455, 1, 0, 0, 0, 4498, - 4464, 1, 0, 0, 0, 4498, 4468, 1, 0, 0, 0, 4498, 4473, 1, 0, 0, 0, 4498, - 4477, 1, 0, 0, 0, 4498, 4479, 1, 0, 0, 0, 4498, 4487, 1, 0, 0, 0, 4498, - 4495, 1, 0, 0, 0, 4499, 515, 1, 0, 0, 0, 4500, 4502, 5, 69, 0, 0, 4501, - 4503, 7, 31, 0, 0, 4502, 4501, 1, 0, 0, 0, 4502, 4503, 1, 0, 0, 0, 4503, - 4504, 1, 0, 0, 0, 4504, 4505, 3, 528, 264, 0, 4505, 4506, 5, 70, 0, 0, - 4506, 4507, 5, 394, 0, 0, 4507, 4508, 5, 463, 0, 0, 4508, 4513, 3, 520, - 260, 0, 4509, 4511, 5, 75, 0, 0, 4510, 4509, 1, 0, 0, 0, 4510, 4511, 1, - 0, 0, 0, 4511, 4512, 1, 0, 0, 0, 4512, 4514, 5, 482, 0, 0, 4513, 4510, - 1, 0, 0, 0, 4513, 4514, 1, 0, 0, 0, 4514, 4518, 1, 0, 0, 0, 4515, 4517, - 3, 518, 259, 0, 4516, 4515, 1, 0, 0, 0, 4517, 4520, 1, 0, 0, 0, 4518, 4516, - 1, 0, 0, 0, 4518, 4519, 1, 0, 0, 0, 4519, 4523, 1, 0, 0, 0, 4520, 4518, - 1, 0, 0, 0, 4521, 4522, 5, 71, 0, 0, 4522, 4524, 3, 608, 304, 0, 4523, - 4521, 1, 0, 0, 0, 4523, 4524, 1, 0, 0, 0, 4524, 4531, 1, 0, 0, 0, 4525, - 4526, 5, 8, 0, 0, 4526, 4529, 3, 556, 278, 0, 4527, 4528, 5, 72, 0, 0, - 4528, 4530, 3, 608, 304, 0, 4529, 4527, 1, 0, 0, 0, 4529, 4530, 1, 0, 0, - 0, 4530, 4532, 1, 0, 0, 0, 4531, 4525, 1, 0, 0, 0, 4531, 4532, 1, 0, 0, - 0, 4532, 4535, 1, 0, 0, 0, 4533, 4534, 5, 9, 0, 0, 4534, 4536, 3, 552, - 276, 0, 4535, 4533, 1, 0, 0, 0, 4535, 4536, 1, 0, 0, 0, 4536, 4539, 1, - 0, 0, 0, 4537, 4538, 5, 74, 0, 0, 4538, 4540, 5, 480, 0, 0, 4539, 4537, - 1, 0, 0, 0, 4539, 4540, 1, 0, 0, 0, 4540, 4543, 1, 0, 0, 0, 4541, 4542, - 5, 73, 0, 0, 4542, 4544, 5, 480, 0, 0, 4543, 4541, 1, 0, 0, 0, 4543, 4544, - 1, 0, 0, 0, 4544, 517, 1, 0, 0, 0, 4545, 4547, 3, 542, 271, 0, 4546, 4545, - 1, 0, 0, 0, 4546, 4547, 1, 0, 0, 0, 4547, 4548, 1, 0, 0, 0, 4548, 4549, - 5, 85, 0, 0, 4549, 4550, 5, 394, 0, 0, 4550, 4551, 5, 463, 0, 0, 4551, - 4556, 3, 520, 260, 0, 4552, 4554, 5, 75, 0, 0, 4553, 4552, 1, 0, 0, 0, - 4553, 4554, 1, 0, 0, 0, 4554, 4555, 1, 0, 0, 0, 4555, 4557, 5, 482, 0, - 0, 4556, 4553, 1, 0, 0, 0, 4556, 4557, 1, 0, 0, 0, 4557, 4560, 1, 0, 0, - 0, 4558, 4559, 5, 92, 0, 0, 4559, 4561, 3, 608, 304, 0, 4560, 4558, 1, - 0, 0, 0, 4560, 4561, 1, 0, 0, 0, 4561, 519, 1, 0, 0, 0, 4562, 4563, 7, - 32, 0, 0, 4563, 521, 1, 0, 0, 0, 4564, 4572, 3, 524, 262, 0, 4565, 4567, - 5, 123, 0, 0, 4566, 4568, 5, 84, 0, 0, 4567, 4566, 1, 0, 0, 0, 4567, 4568, - 1, 0, 0, 0, 4568, 4569, 1, 0, 0, 0, 4569, 4571, 3, 524, 262, 0, 4570, 4565, - 1, 0, 0, 0, 4571, 4574, 1, 0, 0, 0, 4572, 4570, 1, 0, 0, 0, 4572, 4573, - 1, 0, 0, 0, 4573, 523, 1, 0, 0, 0, 4574, 4572, 1, 0, 0, 0, 4575, 4577, - 3, 526, 263, 0, 4576, 4578, 3, 534, 267, 0, 4577, 4576, 1, 0, 0, 0, 4577, - 4578, 1, 0, 0, 0, 4578, 4580, 1, 0, 0, 0, 4579, 4581, 3, 544, 272, 0, 4580, - 4579, 1, 0, 0, 0, 4580, 4581, 1, 0, 0, 0, 4581, 4583, 1, 0, 0, 0, 4582, - 4584, 3, 546, 273, 0, 4583, 4582, 1, 0, 0, 0, 4583, 4584, 1, 0, 0, 0, 4584, - 4586, 1, 0, 0, 0, 4585, 4587, 3, 548, 274, 0, 4586, 4585, 1, 0, 0, 0, 4586, - 4587, 1, 0, 0, 0, 4587, 4589, 1, 0, 0, 0, 4588, 4590, 3, 550, 275, 0, 4589, - 4588, 1, 0, 0, 0, 4589, 4590, 1, 0, 0, 0, 4590, 4592, 1, 0, 0, 0, 4591, - 4593, 3, 558, 279, 0, 4592, 4591, 1, 0, 0, 0, 4592, 4593, 1, 0, 0, 0, 4593, - 4612, 1, 0, 0, 0, 4594, 4596, 3, 534, 267, 0, 4595, 4597, 3, 544, 272, - 0, 4596, 4595, 1, 0, 0, 0, 4596, 4597, 1, 0, 0, 0, 4597, 4599, 1, 0, 0, - 0, 4598, 4600, 3, 546, 273, 0, 4599, 4598, 1, 0, 0, 0, 4599, 4600, 1, 0, - 0, 0, 4600, 4602, 1, 0, 0, 0, 4601, 4603, 3, 548, 274, 0, 4602, 4601, 1, - 0, 0, 0, 4602, 4603, 1, 0, 0, 0, 4603, 4604, 1, 0, 0, 0, 4604, 4606, 3, - 526, 263, 0, 4605, 4607, 3, 550, 275, 0, 4606, 4605, 1, 0, 0, 0, 4606, - 4607, 1, 0, 0, 0, 4607, 4609, 1, 0, 0, 0, 4608, 4610, 3, 558, 279, 0, 4609, - 4608, 1, 0, 0, 0, 4609, 4610, 1, 0, 0, 0, 4610, 4612, 1, 0, 0, 0, 4611, - 4575, 1, 0, 0, 0, 4611, 4594, 1, 0, 0, 0, 4612, 525, 1, 0, 0, 0, 4613, - 4615, 5, 69, 0, 0, 4614, 4616, 7, 31, 0, 0, 4615, 4614, 1, 0, 0, 0, 4615, - 4616, 1, 0, 0, 0, 4616, 4617, 1, 0, 0, 0, 4617, 4618, 3, 528, 264, 0, 4618, - 527, 1, 0, 0, 0, 4619, 4629, 5, 456, 0, 0, 4620, 4625, 3, 530, 265, 0, - 4621, 4622, 5, 462, 0, 0, 4622, 4624, 3, 530, 265, 0, 4623, 4621, 1, 0, - 0, 0, 4624, 4627, 1, 0, 0, 0, 4625, 4623, 1, 0, 0, 0, 4625, 4626, 1, 0, - 0, 0, 4626, 4629, 1, 0, 0, 0, 4627, 4625, 1, 0, 0, 0, 4628, 4619, 1, 0, - 0, 0, 4628, 4620, 1, 0, 0, 0, 4629, 529, 1, 0, 0, 0, 4630, 4633, 3, 608, - 304, 0, 4631, 4632, 5, 75, 0, 0, 4632, 4634, 3, 532, 266, 0, 4633, 4631, - 1, 0, 0, 0, 4633, 4634, 1, 0, 0, 0, 4634, 4641, 1, 0, 0, 0, 4635, 4638, - 3, 634, 317, 0, 4636, 4637, 5, 75, 0, 0, 4637, 4639, 3, 532, 266, 0, 4638, - 4636, 1, 0, 0, 0, 4638, 4639, 1, 0, 0, 0, 4639, 4641, 1, 0, 0, 0, 4640, - 4630, 1, 0, 0, 0, 4640, 4635, 1, 0, 0, 0, 4641, 531, 1, 0, 0, 0, 4642, - 4645, 5, 482, 0, 0, 4643, 4645, 3, 668, 334, 0, 4644, 4642, 1, 0, 0, 0, - 4644, 4643, 1, 0, 0, 0, 4645, 533, 1, 0, 0, 0, 4646, 4647, 5, 70, 0, 0, - 4647, 4651, 3, 536, 268, 0, 4648, 4650, 3, 538, 269, 0, 4649, 4648, 1, - 0, 0, 0, 4650, 4653, 1, 0, 0, 0, 4651, 4649, 1, 0, 0, 0, 4651, 4652, 1, - 0, 0, 0, 4652, 535, 1, 0, 0, 0, 4653, 4651, 1, 0, 0, 0, 4654, 4659, 3, - 646, 323, 0, 4655, 4657, 5, 75, 0, 0, 4656, 4655, 1, 0, 0, 0, 4656, 4657, - 1, 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4660, 5, 482, 0, 0, 4659, 4656, - 1, 0, 0, 0, 4659, 4660, 1, 0, 0, 0, 4660, 4671, 1, 0, 0, 0, 4661, 4662, - 5, 464, 0, 0, 4662, 4663, 3, 522, 261, 0, 4663, 4668, 5, 465, 0, 0, 4664, - 4666, 5, 75, 0, 0, 4665, 4664, 1, 0, 0, 0, 4665, 4666, 1, 0, 0, 0, 4666, - 4667, 1, 0, 0, 0, 4667, 4669, 5, 482, 0, 0, 4668, 4665, 1, 0, 0, 0, 4668, - 4669, 1, 0, 0, 0, 4669, 4671, 1, 0, 0, 0, 4670, 4654, 1, 0, 0, 0, 4670, - 4661, 1, 0, 0, 0, 4671, 537, 1, 0, 0, 0, 4672, 4674, 3, 542, 271, 0, 4673, - 4672, 1, 0, 0, 0, 4673, 4674, 1, 0, 0, 0, 4674, 4675, 1, 0, 0, 0, 4675, - 4676, 5, 85, 0, 0, 4676, 4679, 3, 536, 268, 0, 4677, 4678, 5, 92, 0, 0, - 4678, 4680, 3, 608, 304, 0, 4679, 4677, 1, 0, 0, 0, 4679, 4680, 1, 0, 0, - 0, 4680, 4693, 1, 0, 0, 0, 4681, 4683, 3, 542, 271, 0, 4682, 4681, 1, 0, - 0, 0, 4682, 4683, 1, 0, 0, 0, 4683, 4684, 1, 0, 0, 0, 4684, 4685, 5, 85, - 0, 0, 4685, 4690, 3, 540, 270, 0, 4686, 4688, 5, 75, 0, 0, 4687, 4686, - 1, 0, 0, 0, 4687, 4688, 1, 0, 0, 0, 4688, 4689, 1, 0, 0, 0, 4689, 4691, - 5, 482, 0, 0, 4690, 4687, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4693, - 1, 0, 0, 0, 4692, 4673, 1, 0, 0, 0, 4692, 4682, 1, 0, 0, 0, 4693, 539, - 1, 0, 0, 0, 4694, 4695, 5, 482, 0, 0, 4695, 4696, 5, 457, 0, 0, 4696, 4697, - 3, 646, 323, 0, 4697, 4698, 5, 457, 0, 0, 4698, 4699, 3, 646, 323, 0, 4699, - 4705, 1, 0, 0, 0, 4700, 4701, 3, 646, 323, 0, 4701, 4702, 5, 457, 0, 0, - 4702, 4703, 3, 646, 323, 0, 4703, 4705, 1, 0, 0, 0, 4704, 4694, 1, 0, 0, - 0, 4704, 4700, 1, 0, 0, 0, 4705, 541, 1, 0, 0, 0, 4706, 4708, 5, 86, 0, - 0, 4707, 4709, 5, 89, 0, 0, 4708, 4707, 1, 0, 0, 0, 4708, 4709, 1, 0, 0, - 0, 4709, 4721, 1, 0, 0, 0, 4710, 4712, 5, 87, 0, 0, 4711, 4713, 5, 89, - 0, 0, 4712, 4711, 1, 0, 0, 0, 4712, 4713, 1, 0, 0, 0, 4713, 4721, 1, 0, - 0, 0, 4714, 4721, 5, 88, 0, 0, 4715, 4717, 5, 90, 0, 0, 4716, 4718, 5, - 89, 0, 0, 4717, 4716, 1, 0, 0, 0, 4717, 4718, 1, 0, 0, 0, 4718, 4721, 1, - 0, 0, 0, 4719, 4721, 5, 91, 0, 0, 4720, 4706, 1, 0, 0, 0, 4720, 4710, 1, - 0, 0, 0, 4720, 4714, 1, 0, 0, 0, 4720, 4715, 1, 0, 0, 0, 4720, 4719, 1, - 0, 0, 0, 4721, 543, 1, 0, 0, 0, 4722, 4723, 5, 71, 0, 0, 4723, 4724, 3, - 608, 304, 0, 4724, 545, 1, 0, 0, 0, 4725, 4726, 5, 8, 0, 0, 4726, 4727, - 3, 644, 322, 0, 4727, 547, 1, 0, 0, 0, 4728, 4729, 5, 72, 0, 0, 4729, 4730, - 3, 608, 304, 0, 4730, 549, 1, 0, 0, 0, 4731, 4732, 5, 9, 0, 0, 4732, 4733, - 3, 552, 276, 0, 4733, 551, 1, 0, 0, 0, 4734, 4739, 3, 554, 277, 0, 4735, - 4736, 5, 462, 0, 0, 4736, 4738, 3, 554, 277, 0, 4737, 4735, 1, 0, 0, 0, - 4738, 4741, 1, 0, 0, 0, 4739, 4737, 1, 0, 0, 0, 4739, 4740, 1, 0, 0, 0, - 4740, 553, 1, 0, 0, 0, 4741, 4739, 1, 0, 0, 0, 4742, 4744, 3, 608, 304, - 0, 4743, 4745, 7, 6, 0, 0, 4744, 4743, 1, 0, 0, 0, 4744, 4745, 1, 0, 0, - 0, 4745, 555, 1, 0, 0, 0, 4746, 4751, 3, 608, 304, 0, 4747, 4748, 5, 462, - 0, 0, 4748, 4750, 3, 608, 304, 0, 4749, 4747, 1, 0, 0, 0, 4750, 4753, 1, - 0, 0, 0, 4751, 4749, 1, 0, 0, 0, 4751, 4752, 1, 0, 0, 0, 4752, 557, 1, - 0, 0, 0, 4753, 4751, 1, 0, 0, 0, 4754, 4755, 5, 74, 0, 0, 4755, 4758, 5, - 480, 0, 0, 4756, 4757, 5, 73, 0, 0, 4757, 4759, 5, 480, 0, 0, 4758, 4756, - 1, 0, 0, 0, 4758, 4759, 1, 0, 0, 0, 4759, 4767, 1, 0, 0, 0, 4760, 4761, - 5, 73, 0, 0, 4761, 4764, 5, 480, 0, 0, 4762, 4763, 5, 74, 0, 0, 4763, 4765, - 5, 480, 0, 0, 4764, 4762, 1, 0, 0, 0, 4764, 4765, 1, 0, 0, 0, 4765, 4767, - 1, 0, 0, 0, 4766, 4754, 1, 0, 0, 0, 4766, 4760, 1, 0, 0, 0, 4767, 559, - 1, 0, 0, 0, 4768, 4785, 3, 564, 282, 0, 4769, 4785, 3, 566, 283, 0, 4770, - 4785, 3, 568, 284, 0, 4771, 4785, 3, 570, 285, 0, 4772, 4785, 3, 572, 286, - 0, 4773, 4785, 3, 574, 287, 0, 4774, 4785, 3, 576, 288, 0, 4775, 4785, - 3, 578, 289, 0, 4776, 4785, 3, 562, 281, 0, 4777, 4785, 3, 584, 292, 0, - 4778, 4785, 3, 590, 295, 0, 4779, 4785, 3, 592, 296, 0, 4780, 4785, 3, - 606, 303, 0, 4781, 4785, 3, 594, 297, 0, 4782, 4785, 3, 598, 299, 0, 4783, - 4785, 3, 604, 302, 0, 4784, 4768, 1, 0, 0, 0, 4784, 4769, 1, 0, 0, 0, 4784, - 4770, 1, 0, 0, 0, 4784, 4771, 1, 0, 0, 0, 4784, 4772, 1, 0, 0, 0, 4784, - 4773, 1, 0, 0, 0, 4784, 4774, 1, 0, 0, 0, 4784, 4775, 1, 0, 0, 0, 4784, - 4776, 1, 0, 0, 0, 4784, 4777, 1, 0, 0, 0, 4784, 4778, 1, 0, 0, 0, 4784, - 4779, 1, 0, 0, 0, 4784, 4780, 1, 0, 0, 0, 4784, 4781, 1, 0, 0, 0, 4784, - 4782, 1, 0, 0, 0, 4784, 4783, 1, 0, 0, 0, 4785, 561, 1, 0, 0, 0, 4786, - 4787, 5, 156, 0, 0, 4787, 4788, 5, 478, 0, 0, 4788, 563, 1, 0, 0, 0, 4789, - 4790, 5, 55, 0, 0, 4790, 4791, 5, 410, 0, 0, 4791, 4792, 5, 58, 0, 0, 4792, - 4795, 5, 478, 0, 0, 4793, 4794, 5, 60, 0, 0, 4794, 4796, 5, 478, 0, 0, - 4795, 4793, 1, 0, 0, 0, 4795, 4796, 1, 0, 0, 0, 4796, 4797, 1, 0, 0, 0, - 4797, 4798, 5, 61, 0, 0, 4798, 4813, 5, 478, 0, 0, 4799, 4800, 5, 55, 0, - 0, 4800, 4801, 5, 57, 0, 0, 4801, 4813, 5, 478, 0, 0, 4802, 4803, 5, 55, - 0, 0, 4803, 4804, 5, 59, 0, 0, 4804, 4805, 5, 62, 0, 0, 4805, 4806, 5, - 478, 0, 0, 4806, 4807, 5, 63, 0, 0, 4807, 4810, 5, 480, 0, 0, 4808, 4809, - 5, 61, 0, 0, 4809, 4811, 5, 478, 0, 0, 4810, 4808, 1, 0, 0, 0, 4810, 4811, - 1, 0, 0, 0, 4811, 4813, 1, 0, 0, 0, 4812, 4789, 1, 0, 0, 0, 4812, 4799, - 1, 0, 0, 0, 4812, 4802, 1, 0, 0, 0, 4813, 565, 1, 0, 0, 0, 4814, 4815, - 5, 56, 0, 0, 4815, 567, 1, 0, 0, 0, 4816, 4833, 5, 382, 0, 0, 4817, 4818, - 5, 383, 0, 0, 4818, 4820, 5, 394, 0, 0, 4819, 4821, 5, 90, 0, 0, 4820, - 4819, 1, 0, 0, 0, 4820, 4821, 1, 0, 0, 0, 4821, 4823, 1, 0, 0, 0, 4822, - 4824, 5, 190, 0, 0, 4823, 4822, 1, 0, 0, 0, 4823, 4824, 1, 0, 0, 0, 4824, - 4826, 1, 0, 0, 0, 4825, 4827, 5, 395, 0, 0, 4826, 4825, 1, 0, 0, 0, 4826, - 4827, 1, 0, 0, 0, 4827, 4829, 1, 0, 0, 0, 4828, 4830, 5, 396, 0, 0, 4829, - 4828, 1, 0, 0, 0, 4829, 4830, 1, 0, 0, 0, 4830, 4833, 1, 0, 0, 0, 4831, - 4833, 5, 383, 0, 0, 4832, 4816, 1, 0, 0, 0, 4832, 4817, 1, 0, 0, 0, 4832, - 4831, 1, 0, 0, 0, 4833, 569, 1, 0, 0, 0, 4834, 4835, 5, 384, 0, 0, 4835, - 571, 1, 0, 0, 0, 4836, 4837, 5, 385, 0, 0, 4837, 573, 1, 0, 0, 0, 4838, - 4839, 5, 386, 0, 0, 4839, 4840, 5, 387, 0, 0, 4840, 4841, 5, 478, 0, 0, - 4841, 575, 1, 0, 0, 0, 4842, 4843, 5, 386, 0, 0, 4843, 4844, 5, 59, 0, - 0, 4844, 4845, 5, 478, 0, 0, 4845, 577, 1, 0, 0, 0, 4846, 4848, 5, 388, - 0, 0, 4847, 4849, 3, 580, 290, 0, 4848, 4847, 1, 0, 0, 0, 4848, 4849, 1, - 0, 0, 0, 4849, 4852, 1, 0, 0, 0, 4850, 4851, 5, 417, 0, 0, 4851, 4853, - 3, 582, 291, 0, 4852, 4850, 1, 0, 0, 0, 4852, 4853, 1, 0, 0, 0, 4853, 4858, - 1, 0, 0, 0, 4854, 4855, 5, 64, 0, 0, 4855, 4856, 5, 388, 0, 0, 4856, 4858, - 5, 389, 0, 0, 4857, 4846, 1, 0, 0, 0, 4857, 4854, 1, 0, 0, 0, 4858, 579, - 1, 0, 0, 0, 4859, 4860, 3, 646, 323, 0, 4860, 4861, 5, 463, 0, 0, 4861, - 4862, 5, 456, 0, 0, 4862, 4866, 1, 0, 0, 0, 4863, 4866, 3, 646, 323, 0, - 4864, 4866, 5, 456, 0, 0, 4865, 4859, 1, 0, 0, 0, 4865, 4863, 1, 0, 0, - 0, 4865, 4864, 1, 0, 0, 0, 4866, 581, 1, 0, 0, 0, 4867, 4868, 7, 33, 0, - 0, 4868, 583, 1, 0, 0, 0, 4869, 4870, 5, 66, 0, 0, 4870, 4874, 3, 586, - 293, 0, 4871, 4872, 5, 66, 0, 0, 4872, 4874, 5, 84, 0, 0, 4873, 4869, 1, - 0, 0, 0, 4873, 4871, 1, 0, 0, 0, 4874, 585, 1, 0, 0, 0, 4875, 4880, 3, - 588, 294, 0, 4876, 4877, 5, 462, 0, 0, 4877, 4879, 3, 588, 294, 0, 4878, - 4876, 1, 0, 0, 0, 4879, 4882, 1, 0, 0, 0, 4880, 4878, 1, 0, 0, 0, 4880, - 4881, 1, 0, 0, 0, 4881, 587, 1, 0, 0, 0, 4882, 4880, 1, 0, 0, 0, 4883, - 4884, 7, 34, 0, 0, 4884, 589, 1, 0, 0, 0, 4885, 4886, 5, 67, 0, 0, 4886, - 4887, 5, 330, 0, 0, 4887, 591, 1, 0, 0, 0, 4888, 4889, 5, 68, 0, 0, 4889, - 4890, 5, 478, 0, 0, 4890, 593, 1, 0, 0, 0, 4891, 4892, 5, 418, 0, 0, 4892, - 4893, 5, 55, 0, 0, 4893, 4894, 5, 482, 0, 0, 4894, 4895, 5, 478, 0, 0, - 4895, 4896, 5, 75, 0, 0, 4896, 4951, 5, 482, 0, 0, 4897, 4898, 5, 418, - 0, 0, 4898, 4899, 5, 56, 0, 0, 4899, 4951, 5, 482, 0, 0, 4900, 4901, 5, - 418, 0, 0, 4901, 4951, 5, 375, 0, 0, 4902, 4903, 5, 418, 0, 0, 4903, 4904, - 5, 482, 0, 0, 4904, 4905, 5, 64, 0, 0, 4905, 4951, 5, 482, 0, 0, 4906, - 4907, 5, 418, 0, 0, 4907, 4908, 5, 482, 0, 0, 4908, 4909, 5, 65, 0, 0, - 4909, 4951, 5, 482, 0, 0, 4910, 4911, 5, 418, 0, 0, 4911, 4912, 5, 482, - 0, 0, 4912, 4913, 5, 352, 0, 0, 4913, 4914, 5, 353, 0, 0, 4914, 4915, 5, - 348, 0, 0, 4915, 4928, 3, 648, 324, 0, 4916, 4917, 5, 355, 0, 0, 4917, - 4918, 5, 464, 0, 0, 4918, 4923, 3, 648, 324, 0, 4919, 4920, 5, 462, 0, - 0, 4920, 4922, 3, 648, 324, 0, 4921, 4919, 1, 0, 0, 0, 4922, 4925, 1, 0, - 0, 0, 4923, 4921, 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4926, 1, 0, - 0, 0, 4925, 4923, 1, 0, 0, 0, 4926, 4927, 5, 465, 0, 0, 4927, 4929, 1, - 0, 0, 0, 4928, 4916, 1, 0, 0, 0, 4928, 4929, 1, 0, 0, 0, 4929, 4942, 1, - 0, 0, 0, 4930, 4931, 5, 356, 0, 0, 4931, 4932, 5, 464, 0, 0, 4932, 4937, - 3, 648, 324, 0, 4933, 4934, 5, 462, 0, 0, 4934, 4936, 3, 648, 324, 0, 4935, - 4933, 1, 0, 0, 0, 4936, 4939, 1, 0, 0, 0, 4937, 4935, 1, 0, 0, 0, 4937, - 4938, 1, 0, 0, 0, 4938, 4940, 1, 0, 0, 0, 4939, 4937, 1, 0, 0, 0, 4940, - 4941, 5, 465, 0, 0, 4941, 4943, 1, 0, 0, 0, 4942, 4930, 1, 0, 0, 0, 4942, - 4943, 1, 0, 0, 0, 4943, 4945, 1, 0, 0, 0, 4944, 4946, 5, 354, 0, 0, 4945, - 4944, 1, 0, 0, 0, 4945, 4946, 1, 0, 0, 0, 4946, 4951, 1, 0, 0, 0, 4947, - 4948, 5, 418, 0, 0, 4948, 4949, 5, 482, 0, 0, 4949, 4951, 3, 596, 298, - 0, 4950, 4891, 1, 0, 0, 0, 4950, 4897, 1, 0, 0, 0, 4950, 4900, 1, 0, 0, - 0, 4950, 4902, 1, 0, 0, 0, 4950, 4906, 1, 0, 0, 0, 4950, 4910, 1, 0, 0, - 0, 4950, 4947, 1, 0, 0, 0, 4951, 595, 1, 0, 0, 0, 4952, 4954, 8, 35, 0, - 0, 4953, 4952, 1, 0, 0, 0, 4954, 4955, 1, 0, 0, 0, 4955, 4953, 1, 0, 0, - 0, 4955, 4956, 1, 0, 0, 0, 4956, 597, 1, 0, 0, 0, 4957, 4958, 5, 347, 0, - 0, 4958, 4959, 5, 70, 0, 0, 4959, 4960, 3, 648, 324, 0, 4960, 4961, 5, - 344, 0, 0, 4961, 4962, 7, 25, 0, 0, 4962, 4963, 5, 348, 0, 0, 4963, 4964, - 3, 646, 323, 0, 4964, 4965, 5, 345, 0, 0, 4965, 4966, 5, 464, 0, 0, 4966, - 4971, 3, 600, 300, 0, 4967, 4968, 5, 462, 0, 0, 4968, 4970, 3, 600, 300, - 0, 4969, 4967, 1, 0, 0, 0, 4970, 4973, 1, 0, 0, 0, 4971, 4969, 1, 0, 0, - 0, 4971, 4972, 1, 0, 0, 0, 4972, 4974, 1, 0, 0, 0, 4973, 4971, 1, 0, 0, - 0, 4974, 4987, 5, 465, 0, 0, 4975, 4976, 5, 350, 0, 0, 4976, 4977, 5, 464, - 0, 0, 4977, 4982, 3, 602, 301, 0, 4978, 4979, 5, 462, 0, 0, 4979, 4981, - 3, 602, 301, 0, 4980, 4978, 1, 0, 0, 0, 4981, 4984, 1, 0, 0, 0, 4982, 4980, - 1, 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 4985, 1, 0, 0, 0, 4984, 4982, - 1, 0, 0, 0, 4985, 4986, 5, 465, 0, 0, 4986, 4988, 1, 0, 0, 0, 4987, 4975, - 1, 0, 0, 0, 4987, 4988, 1, 0, 0, 0, 4988, 4991, 1, 0, 0, 0, 4989, 4990, - 5, 349, 0, 0, 4990, 4992, 5, 480, 0, 0, 4991, 4989, 1, 0, 0, 0, 4991, 4992, - 1, 0, 0, 0, 4992, 4995, 1, 0, 0, 0, 4993, 4994, 5, 74, 0, 0, 4994, 4996, - 5, 480, 0, 0, 4995, 4993, 1, 0, 0, 0, 4995, 4996, 1, 0, 0, 0, 4996, 599, - 1, 0, 0, 0, 4997, 4998, 3, 648, 324, 0, 4998, 4999, 5, 75, 0, 0, 4999, - 5000, 3, 648, 324, 0, 5000, 601, 1, 0, 0, 0, 5001, 5002, 3, 648, 324, 0, - 5002, 5003, 5, 410, 0, 0, 5003, 5004, 3, 648, 324, 0, 5004, 5005, 5, 92, - 0, 0, 5005, 5006, 3, 648, 324, 0, 5006, 5012, 1, 0, 0, 0, 5007, 5008, 3, - 648, 324, 0, 5008, 5009, 5, 410, 0, 0, 5009, 5010, 3, 648, 324, 0, 5010, - 5012, 1, 0, 0, 0, 5011, 5001, 1, 0, 0, 0, 5011, 5007, 1, 0, 0, 0, 5012, - 603, 1, 0, 0, 0, 5013, 5014, 5, 482, 0, 0, 5014, 605, 1, 0, 0, 0, 5015, - 5016, 5, 376, 0, 0, 5016, 5017, 5, 377, 0, 0, 5017, 5018, 3, 648, 324, - 0, 5018, 5019, 5, 75, 0, 0, 5019, 5020, 5, 466, 0, 0, 5020, 5021, 3, 364, - 182, 0, 5021, 5022, 5, 467, 0, 0, 5022, 607, 1, 0, 0, 0, 5023, 5024, 3, - 610, 305, 0, 5024, 609, 1, 0, 0, 0, 5025, 5030, 3, 612, 306, 0, 5026, 5027, - 5, 281, 0, 0, 5027, 5029, 3, 612, 306, 0, 5028, 5026, 1, 0, 0, 0, 5029, - 5032, 1, 0, 0, 0, 5030, 5028, 1, 0, 0, 0, 5030, 5031, 1, 0, 0, 0, 5031, - 611, 1, 0, 0, 0, 5032, 5030, 1, 0, 0, 0, 5033, 5038, 3, 614, 307, 0, 5034, - 5035, 5, 280, 0, 0, 5035, 5037, 3, 614, 307, 0, 5036, 5034, 1, 0, 0, 0, - 5037, 5040, 1, 0, 0, 0, 5038, 5036, 1, 0, 0, 0, 5038, 5039, 1, 0, 0, 0, - 5039, 613, 1, 0, 0, 0, 5040, 5038, 1, 0, 0, 0, 5041, 5043, 5, 282, 0, 0, - 5042, 5041, 1, 0, 0, 0, 5042, 5043, 1, 0, 0, 0, 5043, 5044, 1, 0, 0, 0, - 5044, 5045, 3, 616, 308, 0, 5045, 615, 1, 0, 0, 0, 5046, 5075, 3, 620, - 310, 0, 5047, 5048, 3, 618, 309, 0, 5048, 5049, 3, 620, 310, 0, 5049, 5076, - 1, 0, 0, 0, 5050, 5076, 5, 6, 0, 0, 5051, 5076, 5, 5, 0, 0, 5052, 5053, - 5, 284, 0, 0, 5053, 5056, 5, 464, 0, 0, 5054, 5057, 3, 522, 261, 0, 5055, - 5057, 3, 644, 322, 0, 5056, 5054, 1, 0, 0, 0, 5056, 5055, 1, 0, 0, 0, 5057, - 5058, 1, 0, 0, 0, 5058, 5059, 5, 465, 0, 0, 5059, 5076, 1, 0, 0, 0, 5060, - 5062, 5, 282, 0, 0, 5061, 5060, 1, 0, 0, 0, 5061, 5062, 1, 0, 0, 0, 5062, - 5063, 1, 0, 0, 0, 5063, 5064, 5, 285, 0, 0, 5064, 5065, 3, 620, 310, 0, - 5065, 5066, 5, 280, 0, 0, 5066, 5067, 3, 620, 310, 0, 5067, 5076, 1, 0, - 0, 0, 5068, 5070, 5, 282, 0, 0, 5069, 5068, 1, 0, 0, 0, 5069, 5070, 1, - 0, 0, 0, 5070, 5071, 1, 0, 0, 0, 5071, 5072, 5, 286, 0, 0, 5072, 5076, - 3, 620, 310, 0, 5073, 5074, 5, 287, 0, 0, 5074, 5076, 3, 620, 310, 0, 5075, - 5047, 1, 0, 0, 0, 5075, 5050, 1, 0, 0, 0, 5075, 5051, 1, 0, 0, 0, 5075, - 5052, 1, 0, 0, 0, 5075, 5061, 1, 0, 0, 0, 5075, 5069, 1, 0, 0, 0, 5075, - 5073, 1, 0, 0, 0, 5075, 5076, 1, 0, 0, 0, 5076, 617, 1, 0, 0, 0, 5077, - 5078, 7, 36, 0, 0, 5078, 619, 1, 0, 0, 0, 5079, 5084, 3, 622, 311, 0, 5080, - 5081, 7, 37, 0, 0, 5081, 5083, 3, 622, 311, 0, 5082, 5080, 1, 0, 0, 0, - 5083, 5086, 1, 0, 0, 0, 5084, 5082, 1, 0, 0, 0, 5084, 5085, 1, 0, 0, 0, - 5085, 621, 1, 0, 0, 0, 5086, 5084, 1, 0, 0, 0, 5087, 5092, 3, 624, 312, - 0, 5088, 5089, 7, 38, 0, 0, 5089, 5091, 3, 624, 312, 0, 5090, 5088, 1, - 0, 0, 0, 5091, 5094, 1, 0, 0, 0, 5092, 5090, 1, 0, 0, 0, 5092, 5093, 1, - 0, 0, 0, 5093, 623, 1, 0, 0, 0, 5094, 5092, 1, 0, 0, 0, 5095, 5097, 7, - 37, 0, 0, 5096, 5095, 1, 0, 0, 0, 5096, 5097, 1, 0, 0, 0, 5097, 5098, 1, - 0, 0, 0, 5098, 5099, 3, 626, 313, 0, 5099, 625, 1, 0, 0, 0, 5100, 5101, - 5, 464, 0, 0, 5101, 5102, 3, 608, 304, 0, 5102, 5103, 5, 465, 0, 0, 5103, - 5121, 1, 0, 0, 0, 5104, 5105, 5, 464, 0, 0, 5105, 5106, 3, 522, 261, 0, - 5106, 5107, 5, 465, 0, 0, 5107, 5121, 1, 0, 0, 0, 5108, 5109, 5, 288, 0, - 0, 5109, 5110, 5, 464, 0, 0, 5110, 5111, 3, 522, 261, 0, 5111, 5112, 5, - 465, 0, 0, 5112, 5121, 1, 0, 0, 0, 5113, 5121, 3, 628, 314, 0, 5114, 5121, - 3, 630, 315, 0, 5115, 5121, 3, 288, 144, 0, 5116, 5121, 3, 280, 140, 0, - 5117, 5121, 3, 634, 317, 0, 5118, 5121, 3, 636, 318, 0, 5119, 5121, 3, - 642, 321, 0, 5120, 5100, 1, 0, 0, 0, 5120, 5104, 1, 0, 0, 0, 5120, 5108, - 1, 0, 0, 0, 5120, 5113, 1, 0, 0, 0, 5120, 5114, 1, 0, 0, 0, 5120, 5115, - 1, 0, 0, 0, 5120, 5116, 1, 0, 0, 0, 5120, 5117, 1, 0, 0, 0, 5120, 5118, - 1, 0, 0, 0, 5120, 5119, 1, 0, 0, 0, 5121, 627, 1, 0, 0, 0, 5122, 5128, - 5, 78, 0, 0, 5123, 5124, 5, 79, 0, 0, 5124, 5125, 3, 608, 304, 0, 5125, - 5126, 5, 80, 0, 0, 5126, 5127, 3, 608, 304, 0, 5127, 5129, 1, 0, 0, 0, - 5128, 5123, 1, 0, 0, 0, 5129, 5130, 1, 0, 0, 0, 5130, 5128, 1, 0, 0, 0, - 5130, 5131, 1, 0, 0, 0, 5131, 5134, 1, 0, 0, 0, 5132, 5133, 5, 81, 0, 0, - 5133, 5135, 3, 608, 304, 0, 5134, 5132, 1, 0, 0, 0, 5134, 5135, 1, 0, 0, - 0, 5135, 5136, 1, 0, 0, 0, 5136, 5137, 5, 82, 0, 0, 5137, 629, 1, 0, 0, - 0, 5138, 5139, 5, 279, 0, 0, 5139, 5140, 5, 464, 0, 0, 5140, 5141, 3, 608, - 304, 0, 5141, 5142, 5, 75, 0, 0, 5142, 5143, 3, 632, 316, 0, 5143, 5144, - 5, 465, 0, 0, 5144, 631, 1, 0, 0, 0, 5145, 5146, 7, 39, 0, 0, 5146, 633, - 1, 0, 0, 0, 5147, 5148, 7, 40, 0, 0, 5148, 5154, 5, 464, 0, 0, 5149, 5151, - 5, 83, 0, 0, 5150, 5149, 1, 0, 0, 0, 5150, 5151, 1, 0, 0, 0, 5151, 5152, - 1, 0, 0, 0, 5152, 5155, 3, 608, 304, 0, 5153, 5155, 5, 456, 0, 0, 5154, - 5150, 1, 0, 0, 0, 5154, 5153, 1, 0, 0, 0, 5155, 5156, 1, 0, 0, 0, 5156, - 5157, 5, 465, 0, 0, 5157, 635, 1, 0, 0, 0, 5158, 5159, 3, 638, 319, 0, - 5159, 5161, 5, 464, 0, 0, 5160, 5162, 3, 640, 320, 0, 5161, 5160, 1, 0, - 0, 0, 5161, 5162, 1, 0, 0, 0, 5162, 5163, 1, 0, 0, 0, 5163, 5164, 5, 465, - 0, 0, 5164, 637, 1, 0, 0, 0, 5165, 5166, 7, 41, 0, 0, 5166, 639, 1, 0, - 0, 0, 5167, 5172, 3, 608, 304, 0, 5168, 5169, 5, 462, 0, 0, 5169, 5171, - 3, 608, 304, 0, 5170, 5168, 1, 0, 0, 0, 5171, 5174, 1, 0, 0, 0, 5172, 5170, - 1, 0, 0, 0, 5172, 5173, 1, 0, 0, 0, 5173, 641, 1, 0, 0, 0, 5174, 5172, - 1, 0, 0, 0, 5175, 5188, 3, 650, 325, 0, 5176, 5181, 5, 481, 0, 0, 5177, - 5178, 5, 463, 0, 0, 5178, 5180, 3, 94, 47, 0, 5179, 5177, 1, 0, 0, 0, 5180, - 5183, 1, 0, 0, 0, 5181, 5179, 1, 0, 0, 0, 5181, 5182, 1, 0, 0, 0, 5182, - 5188, 1, 0, 0, 0, 5183, 5181, 1, 0, 0, 0, 5184, 5188, 3, 646, 323, 0, 5185, - 5188, 5, 482, 0, 0, 5186, 5188, 5, 477, 0, 0, 5187, 5175, 1, 0, 0, 0, 5187, - 5176, 1, 0, 0, 0, 5187, 5184, 1, 0, 0, 0, 5187, 5185, 1, 0, 0, 0, 5187, - 5186, 1, 0, 0, 0, 5188, 643, 1, 0, 0, 0, 5189, 5194, 3, 608, 304, 0, 5190, - 5191, 5, 462, 0, 0, 5191, 5193, 3, 608, 304, 0, 5192, 5190, 1, 0, 0, 0, - 5193, 5196, 1, 0, 0, 0, 5194, 5192, 1, 0, 0, 0, 5194, 5195, 1, 0, 0, 0, - 5195, 645, 1, 0, 0, 0, 5196, 5194, 1, 0, 0, 0, 5197, 5202, 3, 648, 324, - 0, 5198, 5199, 5, 463, 0, 0, 5199, 5201, 3, 648, 324, 0, 5200, 5198, 1, - 0, 0, 0, 5201, 5204, 1, 0, 0, 0, 5202, 5200, 1, 0, 0, 0, 5202, 5203, 1, - 0, 0, 0, 5203, 647, 1, 0, 0, 0, 5204, 5202, 1, 0, 0, 0, 5205, 5209, 5, - 482, 0, 0, 5206, 5209, 5, 484, 0, 0, 5207, 5209, 3, 670, 335, 0, 5208, - 5205, 1, 0, 0, 0, 5208, 5206, 1, 0, 0, 0, 5208, 5207, 1, 0, 0, 0, 5209, - 649, 1, 0, 0, 0, 5210, 5216, 5, 478, 0, 0, 5211, 5216, 5, 480, 0, 0, 5212, - 5216, 3, 654, 327, 0, 5213, 5216, 5, 283, 0, 0, 5214, 5216, 5, 138, 0, - 0, 5215, 5210, 1, 0, 0, 0, 5215, 5211, 1, 0, 0, 0, 5215, 5212, 1, 0, 0, - 0, 5215, 5213, 1, 0, 0, 0, 5215, 5214, 1, 0, 0, 0, 5216, 651, 1, 0, 0, - 0, 5217, 5226, 5, 468, 0, 0, 5218, 5223, 3, 650, 325, 0, 5219, 5220, 5, - 462, 0, 0, 5220, 5222, 3, 650, 325, 0, 5221, 5219, 1, 0, 0, 0, 5222, 5225, - 1, 0, 0, 0, 5223, 5221, 1, 0, 0, 0, 5223, 5224, 1, 0, 0, 0, 5224, 5227, - 1, 0, 0, 0, 5225, 5223, 1, 0, 0, 0, 5226, 5218, 1, 0, 0, 0, 5226, 5227, - 1, 0, 0, 0, 5227, 5228, 1, 0, 0, 0, 5228, 5229, 5, 469, 0, 0, 5229, 653, - 1, 0, 0, 0, 5230, 5231, 7, 42, 0, 0, 5231, 655, 1, 0, 0, 0, 5232, 5233, - 5, 2, 0, 0, 5233, 657, 1, 0, 0, 0, 5234, 5235, 5, 471, 0, 0, 5235, 5241, - 3, 660, 330, 0, 5236, 5237, 5, 464, 0, 0, 5237, 5238, 3, 662, 331, 0, 5238, - 5239, 5, 465, 0, 0, 5239, 5242, 1, 0, 0, 0, 5240, 5242, 3, 666, 333, 0, - 5241, 5236, 1, 0, 0, 0, 5241, 5240, 1, 0, 0, 0, 5241, 5242, 1, 0, 0, 0, - 5242, 659, 1, 0, 0, 0, 5243, 5244, 7, 43, 0, 0, 5244, 661, 1, 0, 0, 0, - 5245, 5250, 3, 664, 332, 0, 5246, 5247, 5, 462, 0, 0, 5247, 5249, 3, 664, - 332, 0, 5248, 5246, 1, 0, 0, 0, 5249, 5252, 1, 0, 0, 0, 5250, 5248, 1, - 0, 0, 0, 5250, 5251, 1, 0, 0, 0, 5251, 663, 1, 0, 0, 0, 5252, 5250, 1, - 0, 0, 0, 5253, 5254, 5, 482, 0, 0, 5254, 5255, 5, 470, 0, 0, 5255, 5258, - 3, 666, 333, 0, 5256, 5258, 3, 666, 333, 0, 5257, 5253, 1, 0, 0, 0, 5257, - 5256, 1, 0, 0, 0, 5258, 665, 1, 0, 0, 0, 5259, 5263, 3, 650, 325, 0, 5260, - 5263, 3, 608, 304, 0, 5261, 5263, 3, 646, 323, 0, 5262, 5259, 1, 0, 0, - 0, 5262, 5260, 1, 0, 0, 0, 5262, 5261, 1, 0, 0, 0, 5263, 667, 1, 0, 0, - 0, 5264, 5265, 7, 44, 0, 0, 5265, 669, 1, 0, 0, 0, 5266, 5267, 7, 45, 0, - 0, 5267, 671, 1, 0, 0, 0, 603, 675, 681, 686, 689, 692, 701, 711, 720, - 726, 728, 732, 735, 740, 746, 767, 775, 783, 791, 799, 811, 824, 837, 849, - 860, 864, 872, 878, 895, 899, 903, 907, 911, 913, 927, 936, 945, 961, 970, - 985, 999, 1003, 1012, 1015, 1023, 1028, 1030, 1085, 1098, 1109, 1118, 1120, - 1131, 1137, 1145, 1147, 1166, 1174, 1191, 1215, 1231, 1299, 1313, 1327, - 1334, 1342, 1356, 1369, 1373, 1379, 1382, 1388, 1391, 1397, 1401, 1405, - 1411, 1416, 1419, 1421, 1427, 1431, 1435, 1438, 1442, 1447, 1454, 1461, - 1465, 1470, 1479, 1485, 1490, 1496, 1501, 1506, 1511, 1513, 1519, 1551, - 1559, 1580, 1583, 1594, 1599, 1604, 1613, 1618, 1630, 1659, 1669, 1690, - 1704, 1711, 1724, 1731, 1739, 1744, 1749, 1755, 1763, 1770, 1774, 1778, - 1781, 1798, 1803, 1842, 1857, 1864, 1872, 1879, 1883, 1886, 1892, 1895, - 1902, 1906, 1909, 1914, 1921, 1928, 1944, 1949, 1957, 1963, 1968, 1974, - 1979, 1985, 1990, 1995, 2000, 2005, 2010, 2015, 2020, 2025, 2030, 2035, - 2040, 2045, 2050, 2055, 2060, 2065, 2070, 2075, 2080, 2085, 2090, 2095, - 2100, 2105, 2110, 2115, 2120, 2125, 2130, 2135, 2140, 2145, 2150, 2155, - 2160, 2165, 2170, 2175, 2180, 2185, 2190, 2195, 2200, 2205, 2210, 2215, - 2220, 2225, 2230, 2235, 2240, 2245, 2250, 2255, 2260, 2265, 2270, 2275, - 2280, 2285, 2290, 2295, 2300, 2302, 2309, 2314, 2321, 2327, 2330, 2333, - 2339, 2342, 2348, 2352, 2358, 2361, 2364, 2369, 2374, 2383, 2385, 2393, - 2396, 2400, 2404, 2407, 2416, 2438, 2451, 2456, 2466, 2476, 2481, 2489, - 2496, 2500, 2504, 2515, 2522, 2536, 2543, 2547, 2551, 2559, 2563, 2567, - 2577, 2579, 2583, 2586, 2591, 2594, 2597, 2601, 2609, 2613, 2620, 2625, - 2635, 2638, 2642, 2646, 2653, 2660, 2666, 2680, 2687, 2702, 2706, 2713, - 2718, 2722, 2725, 2728, 2732, 2738, 2756, 2761, 2769, 2788, 2853, 2860, - 2865, 2895, 2918, 2929, 2936, 2953, 2956, 2965, 2975, 2987, 2999, 3010, - 3013, 3026, 3034, 3040, 3046, 3054, 3061, 3069, 3076, 3083, 3095, 3098, - 3110, 3134, 3142, 3150, 3170, 3174, 3176, 3184, 3189, 3192, 3202, 3282, - 3292, 3300, 3310, 3314, 3316, 3324, 3327, 3332, 3337, 3343, 3347, 3351, - 3357, 3363, 3368, 3373, 3378, 3383, 3391, 3402, 3407, 3413, 3417, 3426, - 3428, 3430, 3438, 3474, 3477, 3480, 3488, 3495, 3506, 3515, 3521, 3529, - 3538, 3546, 3552, 3556, 3565, 3577, 3583, 3585, 3598, 3602, 3614, 3619, - 3621, 3636, 3641, 3654, 3662, 3673, 3683, 3692, 3699, 3709, 3720, 3739, - 3744, 3755, 3760, 3766, 3770, 3778, 3781, 3797, 3805, 3808, 3815, 3823, - 3828, 3831, 3834, 3844, 3847, 3854, 3857, 3865, 3883, 3889, 3892, 3897, - 3902, 3912, 3931, 3939, 3951, 3958, 3962, 3976, 3986, 3995, 3998, 4010, - 4016, 4025, 4027, 4034, 4036, 4043, 4045, 4052, 4054, 4061, 4063, 4070, - 4072, 4079, 4081, 4088, 4090, 4097, 4099, 4106, 4108, 4115, 4117, 4125, - 4127, 4155, 4162, 4178, 4183, 4194, 4196, 4224, 4226, 4234, 4236, 4244, - 4246, 4254, 4256, 4265, 4275, 4281, 4286, 4288, 4291, 4300, 4302, 4311, - 4313, 4321, 4323, 4335, 4337, 4339, 4347, 4353, 4355, 4360, 4362, 4372, - 4382, 4423, 4453, 4462, 4498, 4502, 4510, 4513, 4518, 4523, 4529, 4531, - 4535, 4539, 4543, 4546, 4553, 4556, 4560, 4567, 4572, 4577, 4580, 4583, - 4586, 4589, 4592, 4596, 4599, 4602, 4606, 4609, 4611, 4615, 4625, 4628, - 4633, 4638, 4640, 4644, 4651, 4656, 4659, 4665, 4668, 4670, 4673, 4679, - 4682, 4687, 4690, 4692, 4704, 4708, 4712, 4717, 4720, 4739, 4744, 4751, - 4758, 4764, 4766, 4784, 4795, 4810, 4812, 4820, 4823, 4826, 4829, 4832, - 4848, 4852, 4857, 4865, 4873, 4880, 4923, 4928, 4937, 4942, 4945, 4950, - 4955, 4971, 4982, 4987, 4991, 4995, 5011, 5030, 5038, 5042, 5056, 5061, - 5069, 5075, 5084, 5092, 5096, 5120, 5130, 5134, 5150, 5154, 5161, 5172, - 5181, 5187, 5194, 5202, 5208, 5215, 5223, 5226, 5241, 5250, 5257, 5262, + 226, 246, 246, 3, 0, 126, 126, 138, 138, 503, 503, 3, 0, 250, 256, 391, + 391, 503, 503, 4, 0, 133, 134, 241, 245, 290, 290, 503, 503, 2, 0, 213, + 213, 501, 501, 1, 0, 407, 409, 1, 0, 499, 500, 4, 0, 193, 193, 318, 318, + 320, 320, 345, 345, 2, 0, 334, 334, 427, 427, 2, 0, 331, 331, 503, 503, + 2, 0, 290, 292, 499, 499, 2, 0, 373, 373, 503, 503, 7, 0, 146, 152, 158, + 160, 163, 163, 167, 174, 192, 193, 222, 226, 503, 503, 2, 0, 286, 286, + 472, 472, 1, 0, 83, 84, 8, 0, 141, 143, 185, 185, 190, 190, 220, 220, 309, + 309, 368, 369, 371, 374, 503, 503, 2, 0, 323, 323, 391, 392, 1, 0, 503, + 504, 2, 1, 478, 478, 482, 482, 1, 0, 469, 474, 1, 0, 475, 476, 2, 0, 477, + 481, 491, 491, 1, 0, 257, 262, 1, 0, 271, 275, 7, 0, 121, 121, 126, 126, + 138, 138, 183, 183, 271, 277, 291, 292, 503, 504, 1, 0, 291, 292, 6, 0, + 48, 48, 186, 187, 215, 215, 296, 296, 394, 394, 503, 503, 37, 0, 41, 43, + 48, 48, 50, 51, 53, 53, 68, 68, 114, 114, 122, 122, 133, 134, 136, 136, + 162, 162, 166, 166, 186, 186, 189, 191, 194, 194, 203, 204, 211, 212, 214, + 215, 218, 218, 227, 227, 242, 242, 271, 275, 297, 297, 299, 299, 325, 326, + 341, 342, 362, 362, 365, 365, 385, 385, 391, 391, 393, 393, 405, 410, 418, + 418, 431, 431, 435, 436, 441, 443, 465, 465, 467, 467, 57, 0, 8, 9, 17, + 21, 23, 30, 32, 35, 38, 43, 47, 48, 50, 51, 53, 53, 55, 58, 64, 66, 68, + 75, 80, 89, 92, 92, 95, 100, 102, 105, 109, 109, 111, 116, 118, 118, 122, + 122, 130, 130, 133, 134, 136, 137, 139, 144, 146, 151, 154, 164, 166, 170, + 172, 173, 177, 177, 185, 186, 189, 194, 203, 212, 214, 215, 217, 218, 222, + 227, 240, 243, 246, 246, 257, 265, 271, 275, 280, 286, 289, 297, 299, 302, + 306, 321, 323, 326, 331, 357, 359, 375, 377, 389, 391, 391, 393, 393, 395, + 396, 398, 416, 418, 418, 420, 420, 423, 423, 425, 456, 462, 465, 467, 468, + 480, 481, 6437, 0, 713, 1, 0, 0, 0, 2, 719, 1, 0, 0, 0, 4, 739, 1, 0, 0, + 0, 6, 741, 1, 0, 0, 0, 8, 773, 1, 0, 0, 0, 10, 903, 1, 0, 0, 0, 12, 917, + 1, 0, 0, 0, 14, 934, 1, 0, 0, 0, 16, 952, 1, 0, 0, 0, 18, 975, 1, 0, 0, + 0, 20, 984, 1, 0, 0, 0, 22, 1000, 1, 0, 0, 0, 24, 1002, 1, 0, 0, 0, 26, + 1012, 1, 0, 0, 0, 28, 1042, 1, 0, 0, 0, 30, 1069, 1, 0, 0, 0, 32, 1127, + 1, 0, 0, 0, 34, 1140, 1, 0, 0, 0, 36, 1189, 1, 0, 0, 0, 38, 1210, 1, 0, + 0, 0, 40, 1212, 1, 0, 0, 0, 42, 1220, 1, 0, 0, 0, 44, 1225, 1, 0, 0, 0, + 46, 1259, 1, 0, 0, 0, 48, 1261, 1, 0, 0, 0, 50, 1266, 1, 0, 0, 0, 52, 1277, + 1, 0, 0, 0, 54, 1282, 1, 0, 0, 0, 56, 1290, 1, 0, 0, 0, 58, 1298, 1, 0, + 0, 0, 60, 1306, 1, 0, 0, 0, 62, 1314, 1, 0, 0, 0, 64, 1322, 1, 0, 0, 0, + 66, 1330, 1, 0, 0, 0, 68, 1339, 1, 0, 0, 0, 70, 1359, 1, 0, 0, 0, 72, 1361, + 1, 0, 0, 0, 74, 1382, 1, 0, 0, 0, 76, 1387, 1, 0, 0, 0, 78, 1393, 1, 0, + 0, 0, 80, 1401, 1, 0, 0, 0, 82, 1437, 1, 0, 0, 0, 84, 1485, 1, 0, 0, 0, + 86, 1491, 1, 0, 0, 0, 88, 1502, 1, 0, 0, 0, 90, 1504, 1, 0, 0, 0, 92, 1518, + 1, 0, 0, 0, 94, 1520, 1, 0, 0, 0, 96, 1529, 1, 0, 0, 0, 98, 1549, 1, 0, + 0, 0, 100, 1584, 1, 0, 0, 0, 102, 1622, 1, 0, 0, 0, 104, 1624, 1, 0, 0, + 0, 106, 1651, 1, 0, 0, 0, 108, 1654, 1, 0, 0, 0, 110, 1660, 1, 0, 0, 0, + 112, 1668, 1, 0, 0, 0, 114, 1675, 1, 0, 0, 0, 116, 1677, 1, 0, 0, 0, 118, + 1687, 1, 0, 0, 0, 120, 1701, 1, 0, 0, 0, 122, 1703, 1, 0, 0, 0, 124, 1761, + 1, 0, 0, 0, 126, 1775, 1, 0, 0, 0, 128, 1795, 1, 0, 0, 0, 130, 1810, 1, + 0, 0, 0, 132, 1812, 1, 0, 0, 0, 134, 1818, 1, 0, 0, 0, 136, 1826, 1, 0, + 0, 0, 138, 1828, 1, 0, 0, 0, 140, 1836, 1, 0, 0, 0, 142, 1845, 1, 0, 0, + 0, 144, 1869, 1, 0, 0, 0, 146, 1872, 1, 0, 0, 0, 148, 1876, 1, 0, 0, 0, + 150, 1879, 1, 0, 0, 0, 152, 1913, 1, 0, 0, 0, 154, 1928, 1, 0, 0, 0, 156, + 1930, 1, 0, 0, 0, 158, 1938, 1, 0, 0, 0, 160, 1946, 1, 0, 0, 0, 162, 1968, + 1, 0, 0, 0, 164, 1987, 1, 0, 0, 0, 166, 1995, 1, 0, 0, 0, 168, 2001, 1, + 0, 0, 0, 170, 2004, 1, 0, 0, 0, 172, 2010, 1, 0, 0, 0, 174, 2020, 1, 0, + 0, 0, 176, 2028, 1, 0, 0, 0, 178, 2030, 1, 0, 0, 0, 180, 2037, 1, 0, 0, + 0, 182, 2045, 1, 0, 0, 0, 184, 2050, 1, 0, 0, 0, 186, 2373, 1, 0, 0, 0, + 188, 2375, 1, 0, 0, 0, 190, 2382, 1, 0, 0, 0, 192, 2392, 1, 0, 0, 0, 194, + 2406, 1, 0, 0, 0, 196, 2415, 1, 0, 0, 0, 198, 2425, 1, 0, 0, 0, 200, 2437, + 1, 0, 0, 0, 202, 2442, 1, 0, 0, 0, 204, 2447, 1, 0, 0, 0, 206, 2487, 1, + 0, 0, 0, 208, 2509, 1, 0, 0, 0, 210, 2511, 1, 0, 0, 0, 212, 2532, 1, 0, + 0, 0, 214, 2544, 1, 0, 0, 0, 216, 2554, 1, 0, 0, 0, 218, 2556, 1, 0, 0, + 0, 220, 2558, 1, 0, 0, 0, 222, 2562, 1, 0, 0, 0, 224, 2565, 1, 0, 0, 0, + 226, 2577, 1, 0, 0, 0, 228, 2593, 1, 0, 0, 0, 230, 2595, 1, 0, 0, 0, 232, + 2601, 1, 0, 0, 0, 234, 2603, 1, 0, 0, 0, 236, 2607, 1, 0, 0, 0, 238, 2622, + 1, 0, 0, 0, 240, 2638, 1, 0, 0, 0, 242, 2672, 1, 0, 0, 0, 244, 2686, 1, + 0, 0, 0, 246, 2696, 1, 0, 0, 0, 248, 2701, 1, 0, 0, 0, 250, 2719, 1, 0, + 0, 0, 252, 2737, 1, 0, 0, 0, 254, 2739, 1, 0, 0, 0, 256, 2742, 1, 0, 0, + 0, 258, 2746, 1, 0, 0, 0, 260, 2760, 1, 0, 0, 0, 262, 2763, 1, 0, 0, 0, + 264, 2777, 1, 0, 0, 0, 266, 2805, 1, 0, 0, 0, 268, 2809, 1, 0, 0, 0, 270, + 2811, 1, 0, 0, 0, 272, 2813, 1, 0, 0, 0, 274, 2818, 1, 0, 0, 0, 276, 2840, + 1, 0, 0, 0, 278, 2842, 1, 0, 0, 0, 280, 2859, 1, 0, 0, 0, 282, 2861, 1, + 0, 0, 0, 284, 2924, 1, 0, 0, 0, 286, 2926, 1, 0, 0, 0, 288, 2934, 1, 0, + 0, 0, 290, 2938, 1, 0, 0, 0, 292, 2966, 1, 0, 0, 0, 294, 2968, 1, 0, 0, + 0, 296, 2974, 1, 0, 0, 0, 298, 2979, 1, 0, 0, 0, 300, 2984, 1, 0, 0, 0, + 302, 2992, 1, 0, 0, 0, 304, 3000, 1, 0, 0, 0, 306, 3002, 1, 0, 0, 0, 308, + 3010, 1, 0, 0, 0, 310, 3014, 1, 0, 0, 0, 312, 3021, 1, 0, 0, 0, 314, 3034, + 1, 0, 0, 0, 316, 3038, 1, 0, 0, 0, 318, 3041, 1, 0, 0, 0, 320, 3049, 1, + 0, 0, 0, 322, 3053, 1, 0, 0, 0, 324, 3061, 1, 0, 0, 0, 326, 3065, 1, 0, + 0, 0, 328, 3073, 1, 0, 0, 0, 330, 3081, 1, 0, 0, 0, 332, 3086, 1, 0, 0, + 0, 334, 3090, 1, 0, 0, 0, 336, 3092, 1, 0, 0, 0, 338, 3100, 1, 0, 0, 0, + 340, 3111, 1, 0, 0, 0, 342, 3113, 1, 0, 0, 0, 344, 3125, 1, 0, 0, 0, 346, + 3127, 1, 0, 0, 0, 348, 3135, 1, 0, 0, 0, 350, 3147, 1, 0, 0, 0, 352, 3149, + 1, 0, 0, 0, 354, 3157, 1, 0, 0, 0, 356, 3159, 1, 0, 0, 0, 358, 3173, 1, + 0, 0, 0, 360, 3175, 1, 0, 0, 0, 362, 3213, 1, 0, 0, 0, 364, 3215, 1, 0, + 0, 0, 366, 3241, 1, 0, 0, 0, 368, 3247, 1, 0, 0, 0, 370, 3250, 1, 0, 0, + 0, 372, 3257, 1, 0, 0, 0, 374, 3265, 1, 0, 0, 0, 376, 3267, 1, 0, 0, 0, + 378, 3353, 1, 0, 0, 0, 380, 3355, 1, 0, 0, 0, 382, 3357, 1, 0, 0, 0, 384, + 3414, 1, 0, 0, 0, 386, 3454, 1, 0, 0, 0, 388, 3456, 1, 0, 0, 0, 390, 3473, + 1, 0, 0, 0, 392, 3478, 1, 0, 0, 0, 394, 3501, 1, 0, 0, 0, 396, 3503, 1, + 0, 0, 0, 398, 3514, 1, 0, 0, 0, 400, 3520, 1, 0, 0, 0, 402, 3522, 1, 0, + 0, 0, 404, 3524, 1, 0, 0, 0, 406, 3526, 1, 0, 0, 0, 408, 3551, 1, 0, 0, + 0, 410, 3566, 1, 0, 0, 0, 412, 3577, 1, 0, 0, 0, 414, 3579, 1, 0, 0, 0, + 416, 3583, 1, 0, 0, 0, 418, 3598, 1, 0, 0, 0, 420, 3602, 1, 0, 0, 0, 422, + 3605, 1, 0, 0, 0, 424, 3611, 1, 0, 0, 0, 426, 3656, 1, 0, 0, 0, 428, 3658, + 1, 0, 0, 0, 430, 3696, 1, 0, 0, 0, 432, 3700, 1, 0, 0, 0, 434, 3710, 1, + 0, 0, 0, 436, 3714, 1, 0, 0, 0, 438, 3717, 1, 0, 0, 0, 440, 3731, 1, 0, + 0, 0, 442, 3744, 1, 0, 0, 0, 444, 3754, 1, 0, 0, 0, 446, 3756, 1, 0, 0, + 0, 448, 3765, 1, 0, 0, 0, 450, 3768, 1, 0, 0, 0, 452, 3780, 1, 0, 0, 0, + 454, 3782, 1, 0, 0, 0, 456, 3786, 1, 0, 0, 0, 458, 3793, 1, 0, 0, 0, 460, + 3801, 1, 0, 0, 0, 462, 3817, 1, 0, 0, 0, 464, 3852, 1, 0, 0, 0, 466, 3854, + 1, 0, 0, 0, 468, 3858, 1, 0, 0, 0, 470, 3862, 1, 0, 0, 0, 472, 3879, 1, + 0, 0, 0, 474, 3881, 1, 0, 0, 0, 476, 3907, 1, 0, 0, 0, 478, 3922, 1, 0, + 0, 0, 480, 3930, 1, 0, 0, 0, 482, 3941, 1, 0, 0, 0, 484, 3965, 1, 0, 0, + 0, 486, 3976, 1, 0, 0, 0, 488, 3988, 1, 0, 0, 0, 490, 3992, 1, 0, 0, 0, + 492, 4014, 1, 0, 0, 0, 494, 4037, 1, 0, 0, 0, 496, 4041, 1, 0, 0, 0, 498, + 4085, 1, 0, 0, 0, 500, 4115, 1, 0, 0, 0, 502, 4214, 1, 0, 0, 0, 504, 4249, + 1, 0, 0, 0, 506, 4251, 1, 0, 0, 0, 508, 4256, 1, 0, 0, 0, 510, 4294, 1, + 0, 0, 0, 512, 4298, 1, 0, 0, 0, 514, 4319, 1, 0, 0, 0, 516, 4335, 1, 0, + 0, 0, 518, 4341, 1, 0, 0, 0, 520, 4352, 1, 0, 0, 0, 522, 4358, 1, 0, 0, + 0, 524, 4365, 1, 0, 0, 0, 526, 4375, 1, 0, 0, 0, 528, 4391, 1, 0, 0, 0, + 530, 4422, 1, 0, 0, 0, 532, 4424, 1, 0, 0, 0, 534, 4426, 1, 0, 0, 0, 536, + 4434, 1, 0, 0, 0, 538, 4440, 1, 0, 0, 0, 540, 4768, 1, 0, 0, 0, 542, 4791, + 1, 0, 0, 0, 544, 4793, 1, 0, 0, 0, 546, 4801, 1, 0, 0, 0, 548, 4803, 1, + 0, 0, 0, 550, 4811, 1, 0, 0, 0, 552, 4927, 1, 0, 0, 0, 554, 4929, 1, 0, + 0, 0, 556, 4975, 1, 0, 0, 0, 558, 4991, 1, 0, 0, 0, 560, 4993, 1, 0, 0, + 0, 562, 5040, 1, 0, 0, 0, 564, 5042, 1, 0, 0, 0, 566, 5057, 1, 0, 0, 0, + 568, 5069, 1, 0, 0, 0, 570, 5073, 1, 0, 0, 0, 572, 5075, 1, 0, 0, 0, 574, + 5099, 1, 0, 0, 0, 576, 5121, 1, 0, 0, 0, 578, 5133, 1, 0, 0, 0, 580, 5149, + 1, 0, 0, 0, 582, 5151, 1, 0, 0, 0, 584, 5154, 1, 0, 0, 0, 586, 5157, 1, + 0, 0, 0, 588, 5160, 1, 0, 0, 0, 590, 5163, 1, 0, 0, 0, 592, 5171, 1, 0, + 0, 0, 594, 5175, 1, 0, 0, 0, 596, 5195, 1, 0, 0, 0, 598, 5213, 1, 0, 0, + 0, 600, 5215, 1, 0, 0, 0, 602, 5241, 1, 0, 0, 0, 604, 5243, 1, 0, 0, 0, + 606, 5261, 1, 0, 0, 0, 608, 5263, 1, 0, 0, 0, 610, 5265, 1, 0, 0, 0, 612, + 5267, 1, 0, 0, 0, 614, 5271, 1, 0, 0, 0, 616, 5286, 1, 0, 0, 0, 618, 5294, + 1, 0, 0, 0, 620, 5296, 1, 0, 0, 0, 622, 5302, 1, 0, 0, 0, 624, 5304, 1, + 0, 0, 0, 626, 5312, 1, 0, 0, 0, 628, 5314, 1, 0, 0, 0, 630, 5317, 1, 0, + 0, 0, 632, 5379, 1, 0, 0, 0, 634, 5382, 1, 0, 0, 0, 636, 5386, 1, 0, 0, + 0, 638, 5426, 1, 0, 0, 0, 640, 5440, 1, 0, 0, 0, 642, 5442, 1, 0, 0, 0, + 644, 5444, 1, 0, 0, 0, 646, 5452, 1, 0, 0, 0, 648, 5454, 1, 0, 0, 0, 650, + 5462, 1, 0, 0, 0, 652, 5471, 1, 0, 0, 0, 654, 5475, 1, 0, 0, 0, 656, 5506, + 1, 0, 0, 0, 658, 5508, 1, 0, 0, 0, 660, 5516, 1, 0, 0, 0, 662, 5525, 1, + 0, 0, 0, 664, 5549, 1, 0, 0, 0, 666, 5551, 1, 0, 0, 0, 668, 5567, 1, 0, + 0, 0, 670, 5574, 1, 0, 0, 0, 672, 5576, 1, 0, 0, 0, 674, 5587, 1, 0, 0, + 0, 676, 5594, 1, 0, 0, 0, 678, 5596, 1, 0, 0, 0, 680, 5616, 1, 0, 0, 0, + 682, 5618, 1, 0, 0, 0, 684, 5626, 1, 0, 0, 0, 686, 5637, 1, 0, 0, 0, 688, + 5644, 1, 0, 0, 0, 690, 5646, 1, 0, 0, 0, 692, 5659, 1, 0, 0, 0, 694, 5661, + 1, 0, 0, 0, 696, 5663, 1, 0, 0, 0, 698, 5672, 1, 0, 0, 0, 700, 5674, 1, + 0, 0, 0, 702, 5686, 1, 0, 0, 0, 704, 5691, 1, 0, 0, 0, 706, 5693, 1, 0, + 0, 0, 708, 5695, 1, 0, 0, 0, 710, 712, 3, 2, 1, 0, 711, 710, 1, 0, 0, 0, + 712, 715, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 713, 714, 1, 0, 0, 0, 714, + 716, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 716, 717, 5, 0, 0, 1, 717, 1, 1, + 0, 0, 0, 718, 720, 3, 694, 347, 0, 719, 718, 1, 0, 0, 0, 719, 720, 1, 0, + 0, 0, 720, 724, 1, 0, 0, 0, 721, 725, 3, 4, 2, 0, 722, 725, 3, 538, 269, + 0, 723, 725, 3, 598, 299, 0, 724, 721, 1, 0, 0, 0, 724, 722, 1, 0, 0, 0, + 724, 723, 1, 0, 0, 0, 725, 727, 1, 0, 0, 0, 726, 728, 5, 482, 0, 0, 727, + 726, 1, 0, 0, 0, 727, 728, 1, 0, 0, 0, 728, 730, 1, 0, 0, 0, 729, 731, + 5, 478, 0, 0, 730, 729, 1, 0, 0, 0, 730, 731, 1, 0, 0, 0, 731, 3, 1, 0, + 0, 0, 732, 740, 3, 8, 4, 0, 733, 740, 3, 10, 5, 0, 734, 740, 3, 32, 16, + 0, 735, 740, 3, 34, 17, 0, 736, 740, 3, 36, 18, 0, 737, 740, 3, 6, 3, 0, + 738, 740, 3, 38, 19, 0, 739, 732, 1, 0, 0, 0, 739, 733, 1, 0, 0, 0, 739, + 734, 1, 0, 0, 0, 739, 735, 1, 0, 0, 0, 739, 736, 1, 0, 0, 0, 739, 737, + 1, 0, 0, 0, 739, 738, 1, 0, 0, 0, 740, 5, 1, 0, 0, 0, 741, 742, 5, 383, + 0, 0, 742, 743, 5, 185, 0, 0, 743, 744, 5, 47, 0, 0, 744, 749, 3, 548, + 274, 0, 745, 746, 5, 483, 0, 0, 746, 748, 3, 548, 274, 0, 747, 745, 1, + 0, 0, 0, 748, 751, 1, 0, 0, 0, 749, 747, 1, 0, 0, 0, 749, 750, 1, 0, 0, + 0, 750, 752, 1, 0, 0, 0, 751, 749, 1, 0, 0, 0, 752, 753, 5, 71, 0, 0, 753, + 758, 3, 546, 273, 0, 754, 755, 5, 280, 0, 0, 755, 757, 3, 546, 273, 0, + 756, 754, 1, 0, 0, 0, 757, 760, 1, 0, 0, 0, 758, 756, 1, 0, 0, 0, 758, + 759, 1, 0, 0, 0, 759, 766, 1, 0, 0, 0, 760, 758, 1, 0, 0, 0, 761, 764, + 5, 284, 0, 0, 762, 765, 3, 684, 342, 0, 763, 765, 5, 503, 0, 0, 764, 762, + 1, 0, 0, 0, 764, 763, 1, 0, 0, 0, 765, 767, 1, 0, 0, 0, 766, 761, 1, 0, + 0, 0, 766, 767, 1, 0, 0, 0, 767, 770, 1, 0, 0, 0, 768, 769, 5, 421, 0, + 0, 769, 771, 5, 422, 0, 0, 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, + 771, 7, 1, 0, 0, 0, 772, 774, 3, 694, 347, 0, 773, 772, 1, 0, 0, 0, 773, + 774, 1, 0, 0, 0, 774, 778, 1, 0, 0, 0, 775, 777, 3, 696, 348, 0, 776, 775, + 1, 0, 0, 0, 777, 780, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 778, 779, 1, 0, + 0, 0, 779, 781, 1, 0, 0, 0, 780, 778, 1, 0, 0, 0, 781, 784, 5, 17, 0, 0, + 782, 783, 5, 281, 0, 0, 783, 785, 7, 0, 0, 0, 784, 782, 1, 0, 0, 0, 784, + 785, 1, 0, 0, 0, 785, 806, 1, 0, 0, 0, 786, 807, 3, 84, 42, 0, 787, 807, + 3, 116, 58, 0, 788, 807, 3, 132, 66, 0, 789, 807, 3, 160, 80, 0, 790, 807, + 3, 162, 81, 0, 791, 807, 3, 310, 155, 0, 792, 807, 3, 312, 156, 0, 793, + 807, 3, 138, 69, 0, 794, 807, 3, 150, 75, 0, 795, 807, 3, 416, 208, 0, + 796, 807, 3, 424, 212, 0, 797, 807, 3, 432, 216, 0, 798, 807, 3, 438, 219, + 0, 799, 807, 3, 458, 229, 0, 800, 807, 3, 460, 230, 0, 801, 807, 3, 462, + 231, 0, 802, 807, 3, 482, 241, 0, 803, 807, 3, 484, 242, 0, 804, 807, 3, + 490, 245, 0, 805, 807, 3, 496, 248, 0, 806, 786, 1, 0, 0, 0, 806, 787, + 1, 0, 0, 0, 806, 788, 1, 0, 0, 0, 806, 789, 1, 0, 0, 0, 806, 790, 1, 0, + 0, 0, 806, 791, 1, 0, 0, 0, 806, 792, 1, 0, 0, 0, 806, 793, 1, 0, 0, 0, + 806, 794, 1, 0, 0, 0, 806, 795, 1, 0, 0, 0, 806, 796, 1, 0, 0, 0, 806, + 797, 1, 0, 0, 0, 806, 798, 1, 0, 0, 0, 806, 799, 1, 0, 0, 0, 806, 800, + 1, 0, 0, 0, 806, 801, 1, 0, 0, 0, 806, 802, 1, 0, 0, 0, 806, 803, 1, 0, + 0, 0, 806, 804, 1, 0, 0, 0, 806, 805, 1, 0, 0, 0, 807, 9, 1, 0, 0, 0, 808, + 809, 5, 18, 0, 0, 809, 810, 5, 23, 0, 0, 810, 812, 3, 684, 342, 0, 811, + 813, 3, 124, 62, 0, 812, 811, 1, 0, 0, 0, 813, 814, 1, 0, 0, 0, 814, 812, + 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 904, 1, 0, 0, 0, 816, 817, 5, 18, + 0, 0, 817, 818, 5, 27, 0, 0, 818, 820, 3, 684, 342, 0, 819, 821, 3, 126, + 63, 0, 820, 819, 1, 0, 0, 0, 821, 822, 1, 0, 0, 0, 822, 820, 1, 0, 0, 0, + 822, 823, 1, 0, 0, 0, 823, 904, 1, 0, 0, 0, 824, 825, 5, 18, 0, 0, 825, + 826, 5, 28, 0, 0, 826, 828, 3, 684, 342, 0, 827, 829, 3, 128, 64, 0, 828, + 827, 1, 0, 0, 0, 829, 830, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 830, 831, + 1, 0, 0, 0, 831, 904, 1, 0, 0, 0, 832, 833, 5, 18, 0, 0, 833, 834, 5, 36, + 0, 0, 834, 836, 3, 684, 342, 0, 835, 837, 3, 130, 65, 0, 836, 835, 1, 0, + 0, 0, 837, 838, 1, 0, 0, 0, 838, 836, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, + 839, 904, 1, 0, 0, 0, 840, 841, 5, 18, 0, 0, 841, 842, 5, 309, 0, 0, 842, + 843, 5, 332, 0, 0, 843, 844, 3, 684, 342, 0, 844, 845, 5, 47, 0, 0, 845, + 850, 3, 468, 234, 0, 846, 847, 5, 483, 0, 0, 847, 849, 3, 468, 234, 0, + 848, 846, 1, 0, 0, 0, 849, 852, 1, 0, 0, 0, 850, 848, 1, 0, 0, 0, 850, + 851, 1, 0, 0, 0, 851, 904, 1, 0, 0, 0, 852, 850, 1, 0, 0, 0, 853, 854, + 5, 18, 0, 0, 854, 855, 5, 309, 0, 0, 855, 856, 5, 307, 0, 0, 856, 857, + 3, 684, 342, 0, 857, 858, 5, 47, 0, 0, 858, 863, 3, 468, 234, 0, 859, 860, + 5, 483, 0, 0, 860, 862, 3, 468, 234, 0, 861, 859, 1, 0, 0, 0, 862, 865, + 1, 0, 0, 0, 863, 861, 1, 0, 0, 0, 863, 864, 1, 0, 0, 0, 864, 904, 1, 0, + 0, 0, 865, 863, 1, 0, 0, 0, 866, 867, 5, 18, 0, 0, 867, 868, 5, 209, 0, + 0, 868, 869, 5, 92, 0, 0, 869, 870, 7, 1, 0, 0, 870, 871, 3, 684, 342, + 0, 871, 872, 5, 184, 0, 0, 872, 874, 5, 503, 0, 0, 873, 875, 3, 12, 6, + 0, 874, 873, 1, 0, 0, 0, 875, 876, 1, 0, 0, 0, 876, 874, 1, 0, 0, 0, 876, + 877, 1, 0, 0, 0, 877, 904, 1, 0, 0, 0, 878, 879, 5, 18, 0, 0, 879, 880, + 5, 428, 0, 0, 880, 904, 3, 530, 265, 0, 881, 882, 5, 18, 0, 0, 882, 883, + 5, 33, 0, 0, 883, 884, 3, 684, 342, 0, 884, 886, 5, 487, 0, 0, 885, 887, + 3, 16, 8, 0, 886, 885, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 886, 1, 0, + 0, 0, 888, 889, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 891, 5, 488, 0, + 0, 891, 904, 1, 0, 0, 0, 892, 893, 5, 18, 0, 0, 893, 894, 5, 34, 0, 0, + 894, 895, 3, 684, 342, 0, 895, 897, 5, 487, 0, 0, 896, 898, 3, 16, 8, 0, + 897, 896, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 897, 1, 0, 0, 0, 899, + 900, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, 902, 5, 488, 0, 0, 902, 904, + 1, 0, 0, 0, 903, 808, 1, 0, 0, 0, 903, 816, 1, 0, 0, 0, 903, 824, 1, 0, + 0, 0, 903, 832, 1, 0, 0, 0, 903, 840, 1, 0, 0, 0, 903, 853, 1, 0, 0, 0, + 903, 866, 1, 0, 0, 0, 903, 878, 1, 0, 0, 0, 903, 881, 1, 0, 0, 0, 903, + 892, 1, 0, 0, 0, 904, 11, 1, 0, 0, 0, 905, 906, 5, 47, 0, 0, 906, 911, + 3, 14, 7, 0, 907, 908, 5, 483, 0, 0, 908, 910, 3, 14, 7, 0, 909, 907, 1, + 0, 0, 0, 910, 913, 1, 0, 0, 0, 911, 909, 1, 0, 0, 0, 911, 912, 1, 0, 0, + 0, 912, 918, 1, 0, 0, 0, 913, 911, 1, 0, 0, 0, 914, 915, 5, 210, 0, 0, + 915, 916, 5, 206, 0, 0, 916, 918, 5, 207, 0, 0, 917, 905, 1, 0, 0, 0, 917, + 914, 1, 0, 0, 0, 918, 13, 1, 0, 0, 0, 919, 920, 5, 203, 0, 0, 920, 921, + 5, 472, 0, 0, 921, 935, 5, 499, 0, 0, 922, 923, 5, 204, 0, 0, 923, 924, + 5, 472, 0, 0, 924, 935, 5, 499, 0, 0, 925, 926, 5, 499, 0, 0, 926, 927, + 5, 472, 0, 0, 927, 935, 5, 499, 0, 0, 928, 929, 5, 499, 0, 0, 929, 930, + 5, 472, 0, 0, 930, 935, 5, 92, 0, 0, 931, 932, 5, 499, 0, 0, 932, 933, + 5, 472, 0, 0, 933, 935, 5, 467, 0, 0, 934, 919, 1, 0, 0, 0, 934, 922, 1, + 0, 0, 0, 934, 925, 1, 0, 0, 0, 934, 928, 1, 0, 0, 0, 934, 931, 1, 0, 0, + 0, 935, 15, 1, 0, 0, 0, 936, 938, 3, 18, 9, 0, 937, 939, 5, 482, 0, 0, + 938, 937, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 939, 953, 1, 0, 0, 0, 940, + 942, 3, 22, 11, 0, 941, 943, 5, 482, 0, 0, 942, 941, 1, 0, 0, 0, 942, 943, + 1, 0, 0, 0, 943, 953, 1, 0, 0, 0, 944, 946, 3, 24, 12, 0, 945, 947, 5, + 482, 0, 0, 946, 945, 1, 0, 0, 0, 946, 947, 1, 0, 0, 0, 947, 953, 1, 0, + 0, 0, 948, 950, 3, 26, 13, 0, 949, 951, 5, 482, 0, 0, 950, 949, 1, 0, 0, + 0, 950, 951, 1, 0, 0, 0, 951, 953, 1, 0, 0, 0, 952, 936, 1, 0, 0, 0, 952, + 940, 1, 0, 0, 0, 952, 944, 1, 0, 0, 0, 952, 948, 1, 0, 0, 0, 953, 17, 1, + 0, 0, 0, 954, 955, 5, 47, 0, 0, 955, 956, 3, 20, 10, 0, 956, 957, 5, 92, + 0, 0, 957, 958, 3, 686, 343, 0, 958, 976, 1, 0, 0, 0, 959, 960, 5, 47, + 0, 0, 960, 961, 5, 485, 0, 0, 961, 966, 3, 20, 10, 0, 962, 963, 5, 483, + 0, 0, 963, 965, 3, 20, 10, 0, 964, 962, 1, 0, 0, 0, 965, 968, 1, 0, 0, + 0, 966, 964, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 969, 1, 0, 0, 0, 968, + 966, 1, 0, 0, 0, 969, 970, 5, 486, 0, 0, 970, 971, 5, 92, 0, 0, 971, 972, + 3, 686, 343, 0, 972, 976, 1, 0, 0, 0, 973, 974, 5, 47, 0, 0, 974, 976, + 3, 20, 10, 0, 975, 954, 1, 0, 0, 0, 975, 959, 1, 0, 0, 0, 975, 973, 1, + 0, 0, 0, 976, 19, 1, 0, 0, 0, 977, 978, 3, 686, 343, 0, 978, 979, 5, 472, + 0, 0, 979, 980, 3, 408, 204, 0, 980, 985, 1, 0, 0, 0, 981, 982, 5, 499, + 0, 0, 982, 983, 5, 472, 0, 0, 983, 985, 3, 408, 204, 0, 984, 977, 1, 0, + 0, 0, 984, 981, 1, 0, 0, 0, 985, 21, 1, 0, 0, 0, 986, 987, 5, 380, 0, 0, + 987, 988, 5, 382, 0, 0, 988, 989, 3, 686, 343, 0, 989, 990, 5, 487, 0, + 0, 990, 991, 3, 368, 184, 0, 991, 992, 5, 488, 0, 0, 992, 1001, 1, 0, 0, + 0, 993, 994, 5, 380, 0, 0, 994, 995, 5, 381, 0, 0, 995, 996, 3, 686, 343, + 0, 996, 997, 5, 487, 0, 0, 997, 998, 3, 368, 184, 0, 998, 999, 5, 488, + 0, 0, 999, 1001, 1, 0, 0, 0, 1000, 986, 1, 0, 0, 0, 1000, 993, 1, 0, 0, + 0, 1001, 23, 1, 0, 0, 0, 1002, 1003, 5, 19, 0, 0, 1003, 1004, 5, 184, 0, + 0, 1004, 1009, 3, 686, 343, 0, 1005, 1006, 5, 483, 0, 0, 1006, 1008, 3, + 686, 343, 0, 1007, 1005, 1, 0, 0, 0, 1008, 1011, 1, 0, 0, 0, 1009, 1007, + 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 25, 1, 0, 0, 0, 1011, 1009, 1, + 0, 0, 0, 1012, 1013, 5, 415, 0, 0, 1013, 1014, 3, 686, 343, 0, 1014, 1015, + 5, 137, 0, 0, 1015, 1016, 5, 487, 0, 0, 1016, 1017, 3, 368, 184, 0, 1017, + 1018, 5, 488, 0, 0, 1018, 27, 1, 0, 0, 0, 1019, 1020, 5, 365, 0, 0, 1020, + 1021, 7, 2, 0, 0, 1021, 1024, 3, 684, 342, 0, 1022, 1023, 5, 414, 0, 0, + 1023, 1025, 3, 684, 342, 0, 1024, 1022, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, + 0, 1025, 1043, 1, 0, 0, 0, 1026, 1027, 5, 366, 0, 0, 1027, 1028, 5, 33, + 0, 0, 1028, 1043, 3, 684, 342, 0, 1029, 1030, 5, 282, 0, 0, 1030, 1031, + 5, 367, 0, 0, 1031, 1032, 5, 33, 0, 0, 1032, 1043, 3, 684, 342, 0, 1033, + 1034, 5, 363, 0, 0, 1034, 1038, 5, 485, 0, 0, 1035, 1037, 3, 30, 15, 0, + 1036, 1035, 1, 0, 0, 0, 1037, 1040, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, + 1038, 1039, 1, 0, 0, 0, 1039, 1041, 1, 0, 0, 0, 1040, 1038, 1, 0, 0, 0, + 1041, 1043, 5, 486, 0, 0, 1042, 1019, 1, 0, 0, 0, 1042, 1026, 1, 0, 0, + 0, 1042, 1029, 1, 0, 0, 0, 1042, 1033, 1, 0, 0, 0, 1043, 29, 1, 0, 0, 0, + 1044, 1045, 5, 363, 0, 0, 1045, 1046, 5, 154, 0, 0, 1046, 1051, 5, 499, + 0, 0, 1047, 1048, 5, 33, 0, 0, 1048, 1052, 3, 684, 342, 0, 1049, 1050, + 5, 30, 0, 0, 1050, 1052, 3, 684, 342, 0, 1051, 1047, 1, 0, 0, 0, 1051, + 1049, 1, 0, 0, 0, 1051, 1052, 1, 0, 0, 0, 1052, 1054, 1, 0, 0, 0, 1053, + 1055, 5, 482, 0, 0, 1054, 1053, 1, 0, 0, 0, 1054, 1055, 1, 0, 0, 0, 1055, + 1070, 1, 0, 0, 0, 1056, 1057, 5, 363, 0, 0, 1057, 1058, 5, 499, 0, 0, 1058, + 1062, 5, 485, 0, 0, 1059, 1061, 3, 30, 15, 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, 1067, 5, 486, 0, 0, 1066, + 1068, 5, 482, 0, 0, 1067, 1066, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, + 1070, 1, 0, 0, 0, 1069, 1044, 1, 0, 0, 0, 1069, 1056, 1, 0, 0, 0, 1070, + 31, 1, 0, 0, 0, 1071, 1072, 5, 19, 0, 0, 1072, 1073, 5, 23, 0, 0, 1073, + 1128, 3, 684, 342, 0, 1074, 1075, 5, 19, 0, 0, 1075, 1076, 5, 27, 0, 0, + 1076, 1128, 3, 684, 342, 0, 1077, 1078, 5, 19, 0, 0, 1078, 1079, 5, 28, + 0, 0, 1079, 1128, 3, 684, 342, 0, 1080, 1081, 5, 19, 0, 0, 1081, 1082, + 5, 37, 0, 0, 1082, 1128, 3, 684, 342, 0, 1083, 1084, 5, 19, 0, 0, 1084, + 1085, 5, 30, 0, 0, 1085, 1128, 3, 684, 342, 0, 1086, 1087, 5, 19, 0, 0, + 1087, 1088, 5, 31, 0, 0, 1088, 1128, 3, 684, 342, 0, 1089, 1090, 5, 19, + 0, 0, 1090, 1091, 5, 33, 0, 0, 1091, 1128, 3, 684, 342, 0, 1092, 1093, + 5, 19, 0, 0, 1093, 1094, 5, 34, 0, 0, 1094, 1128, 3, 684, 342, 0, 1095, + 1096, 5, 19, 0, 0, 1096, 1097, 5, 29, 0, 0, 1097, 1128, 3, 684, 342, 0, + 1098, 1099, 5, 19, 0, 0, 1099, 1100, 5, 36, 0, 0, 1100, 1128, 3, 684, 342, + 0, 1101, 1102, 5, 19, 0, 0, 1102, 1103, 5, 113, 0, 0, 1103, 1104, 5, 114, + 0, 0, 1104, 1128, 3, 684, 342, 0, 1105, 1106, 5, 19, 0, 0, 1106, 1107, + 5, 41, 0, 0, 1107, 1108, 3, 684, 342, 0, 1108, 1109, 5, 92, 0, 0, 1109, + 1110, 3, 684, 342, 0, 1110, 1128, 1, 0, 0, 0, 1111, 1112, 5, 19, 0, 0, + 1112, 1113, 5, 309, 0, 0, 1113, 1114, 5, 332, 0, 0, 1114, 1128, 3, 684, + 342, 0, 1115, 1116, 5, 19, 0, 0, 1116, 1117, 5, 309, 0, 0, 1117, 1118, + 5, 307, 0, 0, 1118, 1128, 3, 684, 342, 0, 1119, 1120, 5, 19, 0, 0, 1120, + 1121, 5, 425, 0, 0, 1121, 1122, 5, 426, 0, 0, 1122, 1123, 5, 307, 0, 0, + 1123, 1128, 3, 684, 342, 0, 1124, 1125, 5, 19, 0, 0, 1125, 1126, 5, 32, + 0, 0, 1126, 1128, 3, 684, 342, 0, 1127, 1071, 1, 0, 0, 0, 1127, 1074, 1, + 0, 0, 0, 1127, 1077, 1, 0, 0, 0, 1127, 1080, 1, 0, 0, 0, 1127, 1083, 1, + 0, 0, 0, 1127, 1086, 1, 0, 0, 0, 1127, 1089, 1, 0, 0, 0, 1127, 1092, 1, + 0, 0, 0, 1127, 1095, 1, 0, 0, 0, 1127, 1098, 1, 0, 0, 0, 1127, 1101, 1, + 0, 0, 0, 1127, 1105, 1, 0, 0, 0, 1127, 1111, 1, 0, 0, 0, 1127, 1115, 1, + 0, 0, 0, 1127, 1119, 1, 0, 0, 0, 1127, 1124, 1, 0, 0, 0, 1128, 33, 1, 0, + 0, 0, 1129, 1130, 5, 20, 0, 0, 1130, 1131, 5, 23, 0, 0, 1131, 1132, 3, + 684, 342, 0, 1132, 1133, 5, 411, 0, 0, 1133, 1134, 5, 503, 0, 0, 1134, + 1141, 1, 0, 0, 0, 1135, 1136, 5, 20, 0, 0, 1136, 1137, 5, 29, 0, 0, 1137, + 1138, 5, 503, 0, 0, 1138, 1139, 5, 411, 0, 0, 1139, 1141, 5, 503, 0, 0, + 1140, 1129, 1, 0, 0, 0, 1140, 1135, 1, 0, 0, 0, 1141, 35, 1, 0, 0, 0, 1142, + 1151, 5, 21, 0, 0, 1143, 1152, 5, 33, 0, 0, 1144, 1152, 5, 30, 0, 0, 1145, + 1152, 5, 34, 0, 0, 1146, 1152, 5, 31, 0, 0, 1147, 1152, 5, 28, 0, 0, 1148, + 1152, 5, 37, 0, 0, 1149, 1150, 5, 344, 0, 0, 1150, 1152, 5, 343, 0, 0, + 1151, 1143, 1, 0, 0, 0, 1151, 1144, 1, 0, 0, 0, 1151, 1145, 1, 0, 0, 0, + 1151, 1146, 1, 0, 0, 0, 1151, 1147, 1, 0, 0, 0, 1151, 1148, 1, 0, 0, 0, + 1151, 1149, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1154, 3, 684, 342, + 0, 1154, 1155, 5, 411, 0, 0, 1155, 1156, 5, 215, 0, 0, 1156, 1162, 5, 499, + 0, 0, 1157, 1160, 5, 284, 0, 0, 1158, 1161, 3, 684, 342, 0, 1159, 1161, + 5, 503, 0, 0, 1160, 1158, 1, 0, 0, 0, 1160, 1159, 1, 0, 0, 0, 1161, 1163, + 1, 0, 0, 0, 1162, 1157, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1190, + 1, 0, 0, 0, 1164, 1173, 5, 21, 0, 0, 1165, 1174, 5, 33, 0, 0, 1166, 1174, + 5, 30, 0, 0, 1167, 1174, 5, 34, 0, 0, 1168, 1174, 5, 31, 0, 0, 1169, 1174, + 5, 28, 0, 0, 1170, 1174, 5, 37, 0, 0, 1171, 1172, 5, 344, 0, 0, 1172, 1174, + 5, 343, 0, 0, 1173, 1165, 1, 0, 0, 0, 1173, 1166, 1, 0, 0, 0, 1173, 1167, + 1, 0, 0, 0, 1173, 1168, 1, 0, 0, 0, 1173, 1169, 1, 0, 0, 0, 1173, 1170, + 1, 0, 0, 0, 1173, 1171, 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1175, 1176, + 3, 684, 342, 0, 1176, 1179, 5, 411, 0, 0, 1177, 1180, 3, 684, 342, 0, 1178, + 1180, 5, 503, 0, 0, 1179, 1177, 1, 0, 0, 0, 1179, 1178, 1, 0, 0, 0, 1180, + 1190, 1, 0, 0, 0, 1181, 1182, 5, 21, 0, 0, 1182, 1183, 5, 23, 0, 0, 1183, + 1184, 3, 684, 342, 0, 1184, 1187, 5, 411, 0, 0, 1185, 1188, 3, 684, 342, + 0, 1186, 1188, 5, 503, 0, 0, 1187, 1185, 1, 0, 0, 0, 1187, 1186, 1, 0, + 0, 0, 1188, 1190, 1, 0, 0, 0, 1189, 1142, 1, 0, 0, 0, 1189, 1164, 1, 0, + 0, 0, 1189, 1181, 1, 0, 0, 0, 1190, 37, 1, 0, 0, 0, 1191, 1211, 3, 40, + 20, 0, 1192, 1211, 3, 42, 21, 0, 1193, 1211, 3, 44, 22, 0, 1194, 1211, + 3, 46, 23, 0, 1195, 1211, 3, 48, 24, 0, 1196, 1211, 3, 50, 25, 0, 1197, + 1211, 3, 52, 26, 0, 1198, 1211, 3, 54, 27, 0, 1199, 1211, 3, 56, 28, 0, + 1200, 1211, 3, 58, 29, 0, 1201, 1211, 3, 60, 30, 0, 1202, 1211, 3, 62, + 31, 0, 1203, 1211, 3, 64, 32, 0, 1204, 1211, 3, 66, 33, 0, 1205, 1211, + 3, 68, 34, 0, 1206, 1211, 3, 70, 35, 0, 1207, 1211, 3, 72, 36, 0, 1208, + 1211, 3, 74, 37, 0, 1209, 1211, 3, 76, 38, 0, 1210, 1191, 1, 0, 0, 0, 1210, + 1192, 1, 0, 0, 0, 1210, 1193, 1, 0, 0, 0, 1210, 1194, 1, 0, 0, 0, 1210, + 1195, 1, 0, 0, 0, 1210, 1196, 1, 0, 0, 0, 1210, 1197, 1, 0, 0, 0, 1210, + 1198, 1, 0, 0, 0, 1210, 1199, 1, 0, 0, 0, 1210, 1200, 1, 0, 0, 0, 1210, + 1201, 1, 0, 0, 0, 1210, 1202, 1, 0, 0, 0, 1210, 1203, 1, 0, 0, 0, 1210, + 1204, 1, 0, 0, 0, 1210, 1205, 1, 0, 0, 0, 1210, 1206, 1, 0, 0, 0, 1210, + 1207, 1, 0, 0, 0, 1210, 1208, 1, 0, 0, 0, 1210, 1209, 1, 0, 0, 0, 1211, + 39, 1, 0, 0, 0, 1212, 1213, 5, 17, 0, 0, 1213, 1214, 5, 29, 0, 0, 1214, + 1215, 5, 431, 0, 0, 1215, 1218, 3, 684, 342, 0, 1216, 1217, 5, 465, 0, + 0, 1217, 1219, 5, 499, 0, 0, 1218, 1216, 1, 0, 0, 0, 1218, 1219, 1, 0, + 0, 0, 1219, 41, 1, 0, 0, 0, 1220, 1221, 5, 19, 0, 0, 1221, 1222, 5, 29, + 0, 0, 1222, 1223, 5, 431, 0, 0, 1223, 1224, 3, 684, 342, 0, 1224, 43, 1, + 0, 0, 0, 1225, 1226, 5, 17, 0, 0, 1226, 1227, 5, 443, 0, 0, 1227, 1228, + 5, 431, 0, 0, 1228, 1229, 3, 686, 343, 0, 1229, 1230, 5, 485, 0, 0, 1230, + 1231, 3, 78, 39, 0, 1231, 1235, 5, 486, 0, 0, 1232, 1233, 5, 437, 0, 0, + 1233, 1234, 5, 84, 0, 0, 1234, 1236, 5, 432, 0, 0, 1235, 1232, 1, 0, 0, + 0, 1235, 1236, 1, 0, 0, 0, 1236, 45, 1, 0, 0, 0, 1237, 1238, 5, 18, 0, + 0, 1238, 1239, 5, 443, 0, 0, 1239, 1240, 5, 431, 0, 0, 1240, 1241, 3, 686, + 343, 0, 1241, 1242, 5, 46, 0, 0, 1242, 1243, 5, 29, 0, 0, 1243, 1244, 5, + 432, 0, 0, 1244, 1245, 5, 485, 0, 0, 1245, 1246, 3, 78, 39, 0, 1246, 1247, + 5, 486, 0, 0, 1247, 1260, 1, 0, 0, 0, 1248, 1249, 5, 18, 0, 0, 1249, 1250, + 5, 443, 0, 0, 1250, 1251, 5, 431, 0, 0, 1251, 1252, 3, 686, 343, 0, 1252, + 1253, 5, 131, 0, 0, 1253, 1254, 5, 29, 0, 0, 1254, 1255, 5, 432, 0, 0, + 1255, 1256, 5, 485, 0, 0, 1256, 1257, 3, 78, 39, 0, 1257, 1258, 5, 486, + 0, 0, 1258, 1260, 1, 0, 0, 0, 1259, 1237, 1, 0, 0, 0, 1259, 1248, 1, 0, + 0, 0, 1260, 47, 1, 0, 0, 0, 1261, 1262, 5, 19, 0, 0, 1262, 1263, 5, 443, + 0, 0, 1263, 1264, 5, 431, 0, 0, 1264, 1265, 3, 686, 343, 0, 1265, 49, 1, + 0, 0, 0, 1266, 1267, 5, 433, 0, 0, 1267, 1268, 3, 78, 39, 0, 1268, 1269, + 5, 92, 0, 0, 1269, 1270, 3, 684, 342, 0, 1270, 1271, 5, 485, 0, 0, 1271, + 1272, 3, 80, 40, 0, 1272, 1275, 5, 486, 0, 0, 1273, 1274, 5, 71, 0, 0, + 1274, 1276, 5, 499, 0, 0, 1275, 1273, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, + 0, 1276, 51, 1, 0, 0, 0, 1277, 1278, 5, 434, 0, 0, 1278, 1279, 3, 78, 39, + 0, 1279, 1280, 5, 92, 0, 0, 1280, 1281, 3, 684, 342, 0, 1281, 53, 1, 0, + 0, 0, 1282, 1283, 5, 433, 0, 0, 1283, 1284, 5, 387, 0, 0, 1284, 1285, 5, + 92, 0, 0, 1285, 1286, 5, 30, 0, 0, 1286, 1287, 3, 684, 342, 0, 1287, 1288, + 5, 411, 0, 0, 1288, 1289, 3, 78, 39, 0, 1289, 55, 1, 0, 0, 0, 1290, 1291, + 5, 434, 0, 0, 1291, 1292, 5, 387, 0, 0, 1292, 1293, 5, 92, 0, 0, 1293, + 1294, 5, 30, 0, 0, 1294, 1295, 3, 684, 342, 0, 1295, 1296, 5, 70, 0, 0, + 1296, 1297, 3, 78, 39, 0, 1297, 57, 1, 0, 0, 0, 1298, 1299, 5, 433, 0, + 0, 1299, 1300, 5, 25, 0, 0, 1300, 1301, 5, 92, 0, 0, 1301, 1302, 5, 33, + 0, 0, 1302, 1303, 3, 684, 342, 0, 1303, 1304, 5, 411, 0, 0, 1304, 1305, + 3, 78, 39, 0, 1305, 59, 1, 0, 0, 0, 1306, 1307, 5, 434, 0, 0, 1307, 1308, + 5, 25, 0, 0, 1308, 1309, 5, 92, 0, 0, 1309, 1310, 5, 33, 0, 0, 1310, 1311, + 3, 684, 342, 0, 1311, 1312, 5, 70, 0, 0, 1312, 1313, 3, 78, 39, 0, 1313, + 61, 1, 0, 0, 0, 1314, 1315, 5, 433, 0, 0, 1315, 1316, 5, 387, 0, 0, 1316, + 1317, 5, 92, 0, 0, 1317, 1318, 5, 32, 0, 0, 1318, 1319, 3, 684, 342, 0, + 1319, 1320, 5, 411, 0, 0, 1320, 1321, 3, 78, 39, 0, 1321, 63, 1, 0, 0, + 0, 1322, 1323, 5, 434, 0, 0, 1323, 1324, 5, 387, 0, 0, 1324, 1325, 5, 92, + 0, 0, 1325, 1326, 5, 32, 0, 0, 1326, 1327, 3, 684, 342, 0, 1327, 1328, + 5, 70, 0, 0, 1328, 1329, 3, 78, 39, 0, 1329, 65, 1, 0, 0, 0, 1330, 1331, + 5, 433, 0, 0, 1331, 1332, 5, 441, 0, 0, 1332, 1333, 5, 92, 0, 0, 1333, + 1334, 5, 309, 0, 0, 1334, 1335, 5, 307, 0, 0, 1335, 1336, 3, 684, 342, + 0, 1336, 1337, 5, 411, 0, 0, 1337, 1338, 3, 78, 39, 0, 1338, 67, 1, 0, + 0, 0, 1339, 1340, 5, 434, 0, 0, 1340, 1341, 5, 441, 0, 0, 1341, 1342, 5, + 92, 0, 0, 1342, 1343, 5, 309, 0, 0, 1343, 1344, 5, 307, 0, 0, 1344, 1345, + 3, 684, 342, 0, 1345, 1346, 5, 70, 0, 0, 1346, 1347, 3, 78, 39, 0, 1347, + 69, 1, 0, 0, 0, 1348, 1349, 5, 18, 0, 0, 1349, 1350, 5, 58, 0, 0, 1350, + 1351, 5, 430, 0, 0, 1351, 1352, 5, 442, 0, 0, 1352, 1360, 7, 3, 0, 0, 1353, + 1354, 5, 18, 0, 0, 1354, 1355, 5, 58, 0, 0, 1355, 1356, 5, 430, 0, 0, 1356, + 1357, 5, 438, 0, 0, 1357, 1358, 5, 468, 0, 0, 1358, 1360, 7, 4, 0, 0, 1359, + 1348, 1, 0, 0, 0, 1359, 1353, 1, 0, 0, 0, 1360, 71, 1, 0, 0, 0, 1361, 1362, + 5, 17, 0, 0, 1362, 1363, 5, 438, 0, 0, 1363, 1364, 5, 443, 0, 0, 1364, + 1365, 5, 499, 0, 0, 1365, 1366, 5, 342, 0, 0, 1366, 1369, 5, 499, 0, 0, + 1367, 1368, 5, 23, 0, 0, 1368, 1370, 3, 684, 342, 0, 1369, 1367, 1, 0, + 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 1372, 5, 485, + 0, 0, 1372, 1377, 3, 686, 343, 0, 1373, 1374, 5, 483, 0, 0, 1374, 1376, + 3, 686, 343, 0, 1375, 1373, 1, 0, 0, 0, 1376, 1379, 1, 0, 0, 0, 1377, 1375, + 1, 0, 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 1380, 1, 0, 0, 0, 1379, 1377, + 1, 0, 0, 0, 1380, 1381, 5, 486, 0, 0, 1381, 73, 1, 0, 0, 0, 1382, 1383, + 5, 19, 0, 0, 1383, 1384, 5, 438, 0, 0, 1384, 1385, 5, 443, 0, 0, 1385, + 1386, 5, 499, 0, 0, 1386, 75, 1, 0, 0, 0, 1387, 1388, 5, 383, 0, 0, 1388, + 1391, 5, 430, 0, 0, 1389, 1390, 5, 284, 0, 0, 1390, 1392, 3, 684, 342, + 0, 1391, 1389, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 77, 1, 0, 0, 0, + 1393, 1398, 3, 684, 342, 0, 1394, 1395, 5, 483, 0, 0, 1395, 1397, 3, 684, + 342, 0, 1396, 1394, 1, 0, 0, 0, 1397, 1400, 1, 0, 0, 0, 1398, 1396, 1, + 0, 0, 0, 1398, 1399, 1, 0, 0, 0, 1399, 79, 1, 0, 0, 0, 1400, 1398, 1, 0, + 0, 0, 1401, 1406, 3, 82, 41, 0, 1402, 1403, 5, 483, 0, 0, 1403, 1405, 3, + 82, 41, 0, 1404, 1402, 1, 0, 0, 0, 1405, 1408, 1, 0, 0, 0, 1406, 1404, + 1, 0, 0, 0, 1406, 1407, 1, 0, 0, 0, 1407, 81, 1, 0, 0, 0, 1408, 1406, 1, + 0, 0, 0, 1409, 1438, 5, 17, 0, 0, 1410, 1438, 5, 99, 0, 0, 1411, 1412, + 5, 463, 0, 0, 1412, 1438, 5, 477, 0, 0, 1413, 1414, 5, 463, 0, 0, 1414, + 1415, 5, 485, 0, 0, 1415, 1420, 5, 503, 0, 0, 1416, 1417, 5, 483, 0, 0, + 1417, 1419, 5, 503, 0, 0, 1418, 1416, 1, 0, 0, 0, 1419, 1422, 1, 0, 0, + 0, 1420, 1418, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1423, 1, 0, 0, + 0, 1422, 1420, 1, 0, 0, 0, 1423, 1438, 5, 486, 0, 0, 1424, 1425, 5, 464, + 0, 0, 1425, 1438, 5, 477, 0, 0, 1426, 1427, 5, 464, 0, 0, 1427, 1428, 5, + 485, 0, 0, 1428, 1433, 5, 503, 0, 0, 1429, 1430, 5, 483, 0, 0, 1430, 1432, + 5, 503, 0, 0, 1431, 1429, 1, 0, 0, 0, 1432, 1435, 1, 0, 0, 0, 1433, 1431, + 1, 0, 0, 0, 1433, 1434, 1, 0, 0, 0, 1434, 1436, 1, 0, 0, 0, 1435, 1433, + 1, 0, 0, 0, 1436, 1438, 5, 486, 0, 0, 1437, 1409, 1, 0, 0, 0, 1437, 1410, + 1, 0, 0, 0, 1437, 1411, 1, 0, 0, 0, 1437, 1413, 1, 0, 0, 0, 1437, 1424, + 1, 0, 0, 0, 1437, 1426, 1, 0, 0, 0, 1438, 83, 1, 0, 0, 0, 1439, 1440, 5, + 24, 0, 0, 1440, 1441, 5, 23, 0, 0, 1441, 1443, 3, 684, 342, 0, 1442, 1444, + 3, 86, 43, 0, 1443, 1442, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 1446, + 1, 0, 0, 0, 1445, 1447, 3, 88, 44, 0, 1446, 1445, 1, 0, 0, 0, 1446, 1447, + 1, 0, 0, 0, 1447, 1486, 1, 0, 0, 0, 1448, 1449, 5, 11, 0, 0, 1449, 1450, + 5, 23, 0, 0, 1450, 1452, 3, 684, 342, 0, 1451, 1453, 3, 86, 43, 0, 1452, + 1451, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 1455, 1, 0, 0, 0, 1454, + 1456, 3, 88, 44, 0, 1455, 1454, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, + 1486, 1, 0, 0, 0, 1457, 1458, 5, 25, 0, 0, 1458, 1459, 5, 23, 0, 0, 1459, + 1461, 3, 684, 342, 0, 1460, 1462, 3, 88, 44, 0, 1461, 1460, 1, 0, 0, 0, + 1461, 1462, 1, 0, 0, 0, 1462, 1463, 1, 0, 0, 0, 1463, 1465, 5, 75, 0, 0, + 1464, 1466, 5, 485, 0, 0, 1465, 1464, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, + 0, 1466, 1467, 1, 0, 0, 0, 1467, 1469, 3, 560, 280, 0, 1468, 1470, 5, 486, + 0, 0, 1469, 1468, 1, 0, 0, 0, 1469, 1470, 1, 0, 0, 0, 1470, 1486, 1, 0, + 0, 0, 1471, 1472, 5, 26, 0, 0, 1472, 1473, 5, 23, 0, 0, 1473, 1475, 3, + 684, 342, 0, 1474, 1476, 3, 88, 44, 0, 1475, 1474, 1, 0, 0, 0, 1475, 1476, + 1, 0, 0, 0, 1476, 1486, 1, 0, 0, 0, 1477, 1478, 5, 23, 0, 0, 1478, 1480, + 3, 684, 342, 0, 1479, 1481, 3, 86, 43, 0, 1480, 1479, 1, 0, 0, 0, 1480, + 1481, 1, 0, 0, 0, 1481, 1483, 1, 0, 0, 0, 1482, 1484, 3, 88, 44, 0, 1483, + 1482, 1, 0, 0, 0, 1483, 1484, 1, 0, 0, 0, 1484, 1486, 1, 0, 0, 0, 1485, + 1439, 1, 0, 0, 0, 1485, 1448, 1, 0, 0, 0, 1485, 1457, 1, 0, 0, 0, 1485, + 1471, 1, 0, 0, 0, 1485, 1477, 1, 0, 0, 0, 1486, 85, 1, 0, 0, 0, 1487, 1488, + 5, 45, 0, 0, 1488, 1492, 3, 684, 342, 0, 1489, 1490, 5, 44, 0, 0, 1490, + 1492, 3, 684, 342, 0, 1491, 1487, 1, 0, 0, 0, 1491, 1489, 1, 0, 0, 0, 1492, + 87, 1, 0, 0, 0, 1493, 1495, 5, 485, 0, 0, 1494, 1496, 3, 94, 47, 0, 1495, + 1494, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, + 1499, 5, 486, 0, 0, 1498, 1500, 3, 90, 45, 0, 1499, 1498, 1, 0, 0, 0, 1499, + 1500, 1, 0, 0, 0, 1500, 1503, 1, 0, 0, 0, 1501, 1503, 3, 90, 45, 0, 1502, + 1493, 1, 0, 0, 0, 1502, 1501, 1, 0, 0, 0, 1503, 89, 1, 0, 0, 0, 1504, 1511, + 3, 92, 46, 0, 1505, 1507, 5, 483, 0, 0, 1506, 1505, 1, 0, 0, 0, 1506, 1507, + 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 1510, 3, 92, 46, 0, 1509, 1506, + 1, 0, 0, 0, 1510, 1513, 1, 0, 0, 0, 1511, 1509, 1, 0, 0, 0, 1511, 1512, + 1, 0, 0, 0, 1512, 91, 1, 0, 0, 0, 1513, 1511, 1, 0, 0, 0, 1514, 1515, 5, + 394, 0, 0, 1515, 1519, 5, 499, 0, 0, 1516, 1517, 5, 41, 0, 0, 1517, 1519, + 3, 108, 54, 0, 1518, 1514, 1, 0, 0, 0, 1518, 1516, 1, 0, 0, 0, 1519, 93, + 1, 0, 0, 0, 1520, 1525, 3, 96, 48, 0, 1521, 1522, 5, 483, 0, 0, 1522, 1524, + 3, 96, 48, 0, 1523, 1521, 1, 0, 0, 0, 1524, 1527, 1, 0, 0, 0, 1525, 1523, + 1, 0, 0, 0, 1525, 1526, 1, 0, 0, 0, 1526, 95, 1, 0, 0, 0, 1527, 1525, 1, + 0, 0, 0, 1528, 1530, 3, 694, 347, 0, 1529, 1528, 1, 0, 0, 0, 1529, 1530, + 1, 0, 0, 0, 1530, 1534, 1, 0, 0, 0, 1531, 1533, 3, 696, 348, 0, 1532, 1531, + 1, 0, 0, 0, 1533, 1536, 1, 0, 0, 0, 1534, 1532, 1, 0, 0, 0, 1534, 1535, + 1, 0, 0, 0, 1535, 1537, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1537, 1538, + 3, 98, 49, 0, 1538, 1539, 5, 491, 0, 0, 1539, 1543, 3, 102, 51, 0, 1540, + 1542, 3, 100, 50, 0, 1541, 1540, 1, 0, 0, 0, 1542, 1545, 1, 0, 0, 0, 1543, + 1541, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 97, 1, 0, 0, 0, 1545, 1543, + 1, 0, 0, 0, 1546, 1550, 5, 503, 0, 0, 1547, 1550, 5, 505, 0, 0, 1548, 1550, + 3, 706, 353, 0, 1549, 1546, 1, 0, 0, 0, 1549, 1547, 1, 0, 0, 0, 1549, 1548, + 1, 0, 0, 0, 1550, 99, 1, 0, 0, 0, 1551, 1554, 5, 7, 0, 0, 1552, 1553, 5, + 297, 0, 0, 1553, 1555, 5, 499, 0, 0, 1554, 1552, 1, 0, 0, 0, 1554, 1555, + 1, 0, 0, 0, 1555, 1585, 1, 0, 0, 0, 1556, 1557, 5, 282, 0, 0, 1557, 1560, + 5, 283, 0, 0, 1558, 1559, 5, 297, 0, 0, 1559, 1561, 5, 499, 0, 0, 1560, + 1558, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1585, 1, 0, 0, 0, 1562, + 1565, 5, 289, 0, 0, 1563, 1564, 5, 297, 0, 0, 1564, 1566, 5, 499, 0, 0, + 1565, 1563, 1, 0, 0, 0, 1565, 1566, 1, 0, 0, 0, 1566, 1585, 1, 0, 0, 0, + 1567, 1570, 5, 290, 0, 0, 1568, 1571, 3, 688, 344, 0, 1569, 1571, 3, 646, + 323, 0, 1570, 1568, 1, 0, 0, 0, 1570, 1569, 1, 0, 0, 0, 1571, 1585, 1, + 0, 0, 0, 1572, 1575, 5, 296, 0, 0, 1573, 1574, 5, 297, 0, 0, 1574, 1576, + 5, 499, 0, 0, 1575, 1573, 1, 0, 0, 0, 1575, 1576, 1, 0, 0, 0, 1576, 1585, + 1, 0, 0, 0, 1577, 1582, 5, 305, 0, 0, 1578, 1580, 5, 462, 0, 0, 1579, 1578, + 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 1583, + 3, 684, 342, 0, 1582, 1579, 1, 0, 0, 0, 1582, 1583, 1, 0, 0, 0, 1583, 1585, + 1, 0, 0, 0, 1584, 1551, 1, 0, 0, 0, 1584, 1556, 1, 0, 0, 0, 1584, 1562, + 1, 0, 0, 0, 1584, 1567, 1, 0, 0, 0, 1584, 1572, 1, 0, 0, 0, 1584, 1577, + 1, 0, 0, 0, 1585, 101, 1, 0, 0, 0, 1586, 1590, 5, 257, 0, 0, 1587, 1588, + 5, 485, 0, 0, 1588, 1589, 5, 501, 0, 0, 1589, 1591, 5, 486, 0, 0, 1590, + 1587, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, 0, 1591, 1623, 1, 0, 0, 0, 1592, + 1623, 5, 258, 0, 0, 1593, 1623, 5, 259, 0, 0, 1594, 1623, 5, 260, 0, 0, + 1595, 1623, 5, 261, 0, 0, 1596, 1623, 5, 262, 0, 0, 1597, 1623, 5, 263, + 0, 0, 1598, 1623, 5, 264, 0, 0, 1599, 1623, 5, 265, 0, 0, 1600, 1623, 5, + 266, 0, 0, 1601, 1623, 5, 267, 0, 0, 1602, 1623, 5, 268, 0, 0, 1603, 1604, + 5, 269, 0, 0, 1604, 1605, 5, 485, 0, 0, 1605, 1606, 3, 104, 52, 0, 1606, + 1607, 5, 486, 0, 0, 1607, 1623, 1, 0, 0, 0, 1608, 1609, 5, 23, 0, 0, 1609, + 1610, 5, 473, 0, 0, 1610, 1611, 5, 503, 0, 0, 1611, 1623, 5, 474, 0, 0, + 1612, 1613, 5, 270, 0, 0, 1613, 1623, 3, 684, 342, 0, 1614, 1615, 5, 28, + 0, 0, 1615, 1616, 5, 485, 0, 0, 1616, 1617, 3, 684, 342, 0, 1617, 1618, + 5, 486, 0, 0, 1618, 1623, 1, 0, 0, 0, 1619, 1620, 5, 13, 0, 0, 1620, 1623, + 3, 684, 342, 0, 1621, 1623, 3, 684, 342, 0, 1622, 1586, 1, 0, 0, 0, 1622, + 1592, 1, 0, 0, 0, 1622, 1593, 1, 0, 0, 0, 1622, 1594, 1, 0, 0, 0, 1622, + 1595, 1, 0, 0, 0, 1622, 1596, 1, 0, 0, 0, 1622, 1597, 1, 0, 0, 0, 1622, + 1598, 1, 0, 0, 0, 1622, 1599, 1, 0, 0, 0, 1622, 1600, 1, 0, 0, 0, 1622, + 1601, 1, 0, 0, 0, 1622, 1602, 1, 0, 0, 0, 1622, 1603, 1, 0, 0, 0, 1622, + 1608, 1, 0, 0, 0, 1622, 1612, 1, 0, 0, 0, 1622, 1614, 1, 0, 0, 0, 1622, + 1619, 1, 0, 0, 0, 1622, 1621, 1, 0, 0, 0, 1623, 103, 1, 0, 0, 0, 1624, + 1625, 7, 5, 0, 0, 1625, 105, 1, 0, 0, 0, 1626, 1630, 5, 257, 0, 0, 1627, + 1628, 5, 485, 0, 0, 1628, 1629, 5, 501, 0, 0, 1629, 1631, 5, 486, 0, 0, + 1630, 1627, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1652, 1, 0, 0, 0, + 1632, 1652, 5, 258, 0, 0, 1633, 1652, 5, 259, 0, 0, 1634, 1652, 5, 260, + 0, 0, 1635, 1652, 5, 261, 0, 0, 1636, 1652, 5, 262, 0, 0, 1637, 1652, 5, + 263, 0, 0, 1638, 1652, 5, 264, 0, 0, 1639, 1652, 5, 265, 0, 0, 1640, 1652, + 5, 266, 0, 0, 1641, 1652, 5, 267, 0, 0, 1642, 1652, 5, 268, 0, 0, 1643, + 1644, 5, 270, 0, 0, 1644, 1652, 3, 684, 342, 0, 1645, 1646, 5, 28, 0, 0, + 1646, 1647, 5, 485, 0, 0, 1647, 1648, 3, 684, 342, 0, 1648, 1649, 5, 486, + 0, 0, 1649, 1652, 1, 0, 0, 0, 1650, 1652, 3, 684, 342, 0, 1651, 1626, 1, + 0, 0, 0, 1651, 1632, 1, 0, 0, 0, 1651, 1633, 1, 0, 0, 0, 1651, 1634, 1, + 0, 0, 0, 1651, 1635, 1, 0, 0, 0, 1651, 1636, 1, 0, 0, 0, 1651, 1637, 1, + 0, 0, 0, 1651, 1638, 1, 0, 0, 0, 1651, 1639, 1, 0, 0, 0, 1651, 1640, 1, + 0, 0, 0, 1651, 1641, 1, 0, 0, 0, 1651, 1642, 1, 0, 0, 0, 1651, 1643, 1, + 0, 0, 0, 1651, 1645, 1, 0, 0, 0, 1651, 1650, 1, 0, 0, 0, 1652, 107, 1, + 0, 0, 0, 1653, 1655, 5, 503, 0, 0, 1654, 1653, 1, 0, 0, 0, 1654, 1655, + 1, 0, 0, 0, 1655, 1656, 1, 0, 0, 0, 1656, 1657, 5, 485, 0, 0, 1657, 1658, + 3, 110, 55, 0, 1658, 1659, 5, 486, 0, 0, 1659, 109, 1, 0, 0, 0, 1660, 1665, + 3, 112, 56, 0, 1661, 1662, 5, 483, 0, 0, 1662, 1664, 3, 112, 56, 0, 1663, + 1661, 1, 0, 0, 0, 1664, 1667, 1, 0, 0, 0, 1665, 1663, 1, 0, 0, 0, 1665, + 1666, 1, 0, 0, 0, 1666, 111, 1, 0, 0, 0, 1667, 1665, 1, 0, 0, 0, 1668, + 1670, 3, 114, 57, 0, 1669, 1671, 7, 6, 0, 0, 1670, 1669, 1, 0, 0, 0, 1670, + 1671, 1, 0, 0, 0, 1671, 113, 1, 0, 0, 0, 1672, 1676, 5, 503, 0, 0, 1673, + 1676, 5, 505, 0, 0, 1674, 1676, 3, 706, 353, 0, 1675, 1672, 1, 0, 0, 0, + 1675, 1673, 1, 0, 0, 0, 1675, 1674, 1, 0, 0, 0, 1676, 115, 1, 0, 0, 0, + 1677, 1678, 5, 27, 0, 0, 1678, 1679, 3, 684, 342, 0, 1679, 1680, 5, 70, + 0, 0, 1680, 1681, 3, 684, 342, 0, 1681, 1682, 5, 411, 0, 0, 1682, 1684, + 3, 684, 342, 0, 1683, 1685, 3, 118, 59, 0, 1684, 1683, 1, 0, 0, 0, 1684, + 1685, 1, 0, 0, 0, 1685, 117, 1, 0, 0, 0, 1686, 1688, 3, 120, 60, 0, 1687, + 1686, 1, 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1687, 1, 0, 0, 0, 1689, + 1690, 1, 0, 0, 0, 1690, 119, 1, 0, 0, 0, 1691, 1692, 5, 405, 0, 0, 1692, + 1702, 7, 7, 0, 0, 1693, 1694, 5, 42, 0, 0, 1694, 1702, 7, 8, 0, 0, 1695, + 1696, 5, 50, 0, 0, 1696, 1702, 7, 9, 0, 0, 1697, 1698, 5, 52, 0, 0, 1698, + 1702, 3, 122, 61, 0, 1699, 1700, 5, 394, 0, 0, 1700, 1702, 5, 499, 0, 0, + 1701, 1691, 1, 0, 0, 0, 1701, 1693, 1, 0, 0, 0, 1701, 1695, 1, 0, 0, 0, + 1701, 1697, 1, 0, 0, 0, 1701, 1699, 1, 0, 0, 0, 1702, 121, 1, 0, 0, 0, + 1703, 1704, 7, 10, 0, 0, 1704, 123, 1, 0, 0, 0, 1705, 1706, 5, 46, 0, 0, + 1706, 1707, 5, 38, 0, 0, 1707, 1762, 3, 96, 48, 0, 1708, 1709, 5, 46, 0, + 0, 1709, 1710, 5, 39, 0, 0, 1710, 1762, 3, 96, 48, 0, 1711, 1712, 5, 20, + 0, 0, 1712, 1713, 5, 38, 0, 0, 1713, 1714, 3, 98, 49, 0, 1714, 1715, 5, + 411, 0, 0, 1715, 1716, 3, 98, 49, 0, 1716, 1762, 1, 0, 0, 0, 1717, 1718, + 5, 20, 0, 0, 1718, 1719, 5, 39, 0, 0, 1719, 1720, 3, 98, 49, 0, 1720, 1721, + 5, 411, 0, 0, 1721, 1722, 3, 98, 49, 0, 1722, 1762, 1, 0, 0, 0, 1723, 1724, + 5, 22, 0, 0, 1724, 1725, 5, 38, 0, 0, 1725, 1726, 3, 98, 49, 0, 1726, 1730, + 3, 102, 51, 0, 1727, 1729, 3, 100, 50, 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, + 1762, 1, 0, 0, 0, 1732, 1730, 1, 0, 0, 0, 1733, 1734, 5, 22, 0, 0, 1734, + 1735, 5, 39, 0, 0, 1735, 1736, 3, 98, 49, 0, 1736, 1740, 3, 102, 51, 0, + 1737, 1739, 3, 100, 50, 0, 1738, 1737, 1, 0, 0, 0, 1739, 1742, 1, 0, 0, + 0, 1740, 1738, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1762, 1, 0, 0, + 0, 1742, 1740, 1, 0, 0, 0, 1743, 1744, 5, 19, 0, 0, 1744, 1745, 5, 38, + 0, 0, 1745, 1762, 3, 98, 49, 0, 1746, 1747, 5, 19, 0, 0, 1747, 1748, 5, + 39, 0, 0, 1748, 1762, 3, 98, 49, 0, 1749, 1750, 5, 47, 0, 0, 1750, 1751, + 5, 49, 0, 0, 1751, 1762, 5, 499, 0, 0, 1752, 1753, 5, 47, 0, 0, 1753, 1754, + 5, 394, 0, 0, 1754, 1762, 5, 499, 0, 0, 1755, 1756, 5, 46, 0, 0, 1756, + 1757, 5, 41, 0, 0, 1757, 1762, 3, 108, 54, 0, 1758, 1759, 5, 19, 0, 0, + 1759, 1760, 5, 41, 0, 0, 1760, 1762, 5, 503, 0, 0, 1761, 1705, 1, 0, 0, + 0, 1761, 1708, 1, 0, 0, 0, 1761, 1711, 1, 0, 0, 0, 1761, 1717, 1, 0, 0, + 0, 1761, 1723, 1, 0, 0, 0, 1761, 1733, 1, 0, 0, 0, 1761, 1743, 1, 0, 0, + 0, 1761, 1746, 1, 0, 0, 0, 1761, 1749, 1, 0, 0, 0, 1761, 1752, 1, 0, 0, + 0, 1761, 1755, 1, 0, 0, 0, 1761, 1758, 1, 0, 0, 0, 1762, 125, 1, 0, 0, + 0, 1763, 1764, 5, 47, 0, 0, 1764, 1765, 5, 52, 0, 0, 1765, 1776, 3, 122, + 61, 0, 1766, 1767, 5, 47, 0, 0, 1767, 1768, 5, 42, 0, 0, 1768, 1776, 7, + 8, 0, 0, 1769, 1770, 5, 47, 0, 0, 1770, 1771, 5, 50, 0, 0, 1771, 1776, + 7, 9, 0, 0, 1772, 1773, 5, 47, 0, 0, 1773, 1774, 5, 394, 0, 0, 1774, 1776, + 5, 499, 0, 0, 1775, 1763, 1, 0, 0, 0, 1775, 1766, 1, 0, 0, 0, 1775, 1769, + 1, 0, 0, 0, 1775, 1772, 1, 0, 0, 0, 1776, 127, 1, 0, 0, 0, 1777, 1778, + 5, 46, 0, 0, 1778, 1779, 5, 406, 0, 0, 1779, 1782, 5, 503, 0, 0, 1780, + 1781, 5, 186, 0, 0, 1781, 1783, 5, 499, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, + 1783, 1, 0, 0, 0, 1783, 1796, 1, 0, 0, 0, 1784, 1785, 5, 20, 0, 0, 1785, + 1786, 5, 406, 0, 0, 1786, 1787, 5, 503, 0, 0, 1787, 1788, 5, 411, 0, 0, + 1788, 1796, 5, 503, 0, 0, 1789, 1790, 5, 19, 0, 0, 1790, 1791, 5, 406, + 0, 0, 1791, 1796, 5, 503, 0, 0, 1792, 1793, 5, 47, 0, 0, 1793, 1794, 5, + 394, 0, 0, 1794, 1796, 5, 499, 0, 0, 1795, 1777, 1, 0, 0, 0, 1795, 1784, + 1, 0, 0, 0, 1795, 1789, 1, 0, 0, 0, 1795, 1792, 1, 0, 0, 0, 1796, 129, + 1, 0, 0, 0, 1797, 1798, 5, 46, 0, 0, 1798, 1799, 5, 33, 0, 0, 1799, 1802, + 3, 684, 342, 0, 1800, 1801, 5, 48, 0, 0, 1801, 1803, 5, 501, 0, 0, 1802, + 1800, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1811, 1, 0, 0, 0, 1804, + 1805, 5, 19, 0, 0, 1805, 1806, 5, 33, 0, 0, 1806, 1811, 3, 684, 342, 0, + 1807, 1808, 5, 47, 0, 0, 1808, 1809, 5, 394, 0, 0, 1809, 1811, 5, 499, + 0, 0, 1810, 1797, 1, 0, 0, 0, 1810, 1804, 1, 0, 0, 0, 1810, 1807, 1, 0, + 0, 0, 1811, 131, 1, 0, 0, 0, 1812, 1813, 5, 29, 0, 0, 1813, 1815, 5, 503, + 0, 0, 1814, 1816, 3, 134, 67, 0, 1815, 1814, 1, 0, 0, 0, 1815, 1816, 1, + 0, 0, 0, 1816, 133, 1, 0, 0, 0, 1817, 1819, 3, 136, 68, 0, 1818, 1817, + 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1820, 1821, + 1, 0, 0, 0, 1821, 135, 1, 0, 0, 0, 1822, 1823, 5, 394, 0, 0, 1823, 1827, + 5, 499, 0, 0, 1824, 1825, 5, 215, 0, 0, 1825, 1827, 5, 499, 0, 0, 1826, + 1822, 1, 0, 0, 0, 1826, 1824, 1, 0, 0, 0, 1827, 137, 1, 0, 0, 0, 1828, + 1829, 5, 28, 0, 0, 1829, 1830, 3, 684, 342, 0, 1830, 1831, 5, 485, 0, 0, + 1831, 1832, 3, 140, 70, 0, 1832, 1834, 5, 486, 0, 0, 1833, 1835, 3, 146, + 73, 0, 1834, 1833, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, 1835, 139, 1, 0, + 0, 0, 1836, 1841, 3, 142, 71, 0, 1837, 1838, 5, 483, 0, 0, 1838, 1840, + 3, 142, 71, 0, 1839, 1837, 1, 0, 0, 0, 1840, 1843, 1, 0, 0, 0, 1841, 1839, + 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 141, 1, 0, 0, 0, 1843, 1841, + 1, 0, 0, 0, 1844, 1846, 3, 694, 347, 0, 1845, 1844, 1, 0, 0, 0, 1845, 1846, + 1, 0, 0, 0, 1846, 1847, 1, 0, 0, 0, 1847, 1852, 3, 144, 72, 0, 1848, 1850, + 5, 186, 0, 0, 1849, 1848, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1851, + 1, 0, 0, 0, 1851, 1853, 5, 499, 0, 0, 1852, 1849, 1, 0, 0, 0, 1852, 1853, + 1, 0, 0, 0, 1853, 143, 1, 0, 0, 0, 1854, 1870, 5, 503, 0, 0, 1855, 1870, + 5, 505, 0, 0, 1856, 1870, 3, 706, 353, 0, 1857, 1870, 5, 307, 0, 0, 1858, + 1870, 5, 308, 0, 0, 1859, 1870, 5, 338, 0, 0, 1860, 1870, 5, 337, 0, 0, + 1861, 1870, 5, 313, 0, 0, 1862, 1870, 5, 332, 0, 0, 1863, 1870, 5, 333, + 0, 0, 1864, 1870, 5, 334, 0, 0, 1865, 1870, 5, 335, 0, 0, 1866, 1870, 5, + 26, 0, 0, 1867, 1870, 5, 339, 0, 0, 1868, 1870, 5, 361, 0, 0, 1869, 1854, + 1, 0, 0, 0, 1869, 1855, 1, 0, 0, 0, 1869, 1856, 1, 0, 0, 0, 1869, 1857, + 1, 0, 0, 0, 1869, 1858, 1, 0, 0, 0, 1869, 1859, 1, 0, 0, 0, 1869, 1860, + 1, 0, 0, 0, 1869, 1861, 1, 0, 0, 0, 1869, 1862, 1, 0, 0, 0, 1869, 1863, + 1, 0, 0, 0, 1869, 1864, 1, 0, 0, 0, 1869, 1865, 1, 0, 0, 0, 1869, 1866, + 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1869, 1868, 1, 0, 0, 0, 1870, 145, + 1, 0, 0, 0, 1871, 1873, 3, 148, 74, 0, 1872, 1871, 1, 0, 0, 0, 1873, 1874, + 1, 0, 0, 0, 1874, 1872, 1, 0, 0, 0, 1874, 1875, 1, 0, 0, 0, 1875, 147, + 1, 0, 0, 0, 1876, 1877, 5, 394, 0, 0, 1877, 1878, 5, 499, 0, 0, 1878, 149, + 1, 0, 0, 0, 1879, 1880, 5, 293, 0, 0, 1880, 1881, 5, 295, 0, 0, 1881, 1882, + 3, 684, 342, 0, 1882, 1883, 5, 414, 0, 0, 1883, 1884, 3, 684, 342, 0, 1884, + 1885, 3, 152, 76, 0, 1885, 151, 1, 0, 0, 0, 1886, 1887, 5, 302, 0, 0, 1887, + 1888, 3, 646, 323, 0, 1888, 1889, 5, 294, 0, 0, 1889, 1890, 5, 499, 0, + 0, 1890, 1914, 1, 0, 0, 0, 1891, 1892, 5, 296, 0, 0, 1892, 1893, 3, 156, + 78, 0, 1893, 1894, 5, 294, 0, 0, 1894, 1895, 5, 499, 0, 0, 1895, 1914, + 1, 0, 0, 0, 1896, 1897, 5, 289, 0, 0, 1897, 1898, 3, 158, 79, 0, 1898, + 1899, 5, 294, 0, 0, 1899, 1900, 5, 499, 0, 0, 1900, 1914, 1, 0, 0, 0, 1901, + 1902, 5, 299, 0, 0, 1902, 1903, 3, 156, 78, 0, 1903, 1904, 3, 154, 77, + 0, 1904, 1905, 5, 294, 0, 0, 1905, 1906, 5, 499, 0, 0, 1906, 1914, 1, 0, + 0, 0, 1907, 1908, 5, 300, 0, 0, 1908, 1909, 3, 156, 78, 0, 1909, 1910, + 5, 499, 0, 0, 1910, 1911, 5, 294, 0, 0, 1911, 1912, 5, 499, 0, 0, 1912, + 1914, 1, 0, 0, 0, 1913, 1886, 1, 0, 0, 0, 1913, 1891, 1, 0, 0, 0, 1913, + 1896, 1, 0, 0, 0, 1913, 1901, 1, 0, 0, 0, 1913, 1907, 1, 0, 0, 0, 1914, + 153, 1, 0, 0, 0, 1915, 1916, 5, 285, 0, 0, 1916, 1917, 3, 688, 344, 0, + 1917, 1918, 5, 280, 0, 0, 1918, 1919, 3, 688, 344, 0, 1919, 1929, 1, 0, + 0, 0, 1920, 1921, 5, 473, 0, 0, 1921, 1929, 3, 688, 344, 0, 1922, 1923, + 5, 470, 0, 0, 1923, 1929, 3, 688, 344, 0, 1924, 1925, 5, 474, 0, 0, 1925, + 1929, 3, 688, 344, 0, 1926, 1927, 5, 471, 0, 0, 1927, 1929, 3, 688, 344, + 0, 1928, 1915, 1, 0, 0, 0, 1928, 1920, 1, 0, 0, 0, 1928, 1922, 1, 0, 0, + 0, 1928, 1924, 1, 0, 0, 0, 1928, 1926, 1, 0, 0, 0, 1929, 155, 1, 0, 0, + 0, 1930, 1935, 5, 503, 0, 0, 1931, 1932, 5, 478, 0, 0, 1932, 1934, 5, 503, + 0, 0, 1933, 1931, 1, 0, 0, 0, 1934, 1937, 1, 0, 0, 0, 1935, 1933, 1, 0, + 0, 0, 1935, 1936, 1, 0, 0, 0, 1936, 157, 1, 0, 0, 0, 1937, 1935, 1, 0, + 0, 0, 1938, 1943, 3, 156, 78, 0, 1939, 1940, 5, 483, 0, 0, 1940, 1942, + 3, 156, 78, 0, 1941, 1939, 1, 0, 0, 0, 1942, 1945, 1, 0, 0, 0, 1943, 1941, + 1, 0, 0, 0, 1943, 1944, 1, 0, 0, 0, 1944, 159, 1, 0, 0, 0, 1945, 1943, + 1, 0, 0, 0, 1946, 1947, 5, 30, 0, 0, 1947, 1948, 3, 684, 342, 0, 1948, + 1950, 5, 485, 0, 0, 1949, 1951, 3, 172, 86, 0, 1950, 1949, 1, 0, 0, 0, + 1950, 1951, 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 1954, 5, 486, 0, + 0, 1953, 1955, 3, 178, 89, 0, 1954, 1953, 1, 0, 0, 0, 1954, 1955, 1, 0, + 0, 0, 1955, 1957, 1, 0, 0, 0, 1956, 1958, 3, 180, 90, 0, 1957, 1956, 1, + 0, 0, 0, 1957, 1958, 1, 0, 0, 0, 1958, 1959, 1, 0, 0, 0, 1959, 1960, 5, + 95, 0, 0, 1960, 1961, 3, 184, 92, 0, 1961, 1963, 5, 82, 0, 0, 1962, 1964, + 5, 482, 0, 0, 1963, 1962, 1, 0, 0, 0, 1963, 1964, 1, 0, 0, 0, 1964, 1966, + 1, 0, 0, 0, 1965, 1967, 5, 478, 0, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, + 1, 0, 0, 0, 1967, 161, 1, 0, 0, 0, 1968, 1969, 5, 113, 0, 0, 1969, 1970, + 5, 114, 0, 0, 1970, 1971, 3, 684, 342, 0, 1971, 1973, 5, 485, 0, 0, 1972, + 1974, 3, 164, 82, 0, 1973, 1972, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, + 1975, 1, 0, 0, 0, 1975, 1977, 5, 486, 0, 0, 1976, 1978, 3, 168, 84, 0, + 1977, 1976, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1980, 1, 0, 0, 0, + 1979, 1981, 3, 170, 85, 0, 1980, 1979, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, + 0, 1981, 1982, 1, 0, 0, 0, 1982, 1983, 5, 75, 0, 0, 1983, 1985, 5, 500, + 0, 0, 1984, 1986, 5, 482, 0, 0, 1985, 1984, 1, 0, 0, 0, 1985, 1986, 1, + 0, 0, 0, 1986, 163, 1, 0, 0, 0, 1987, 1992, 3, 166, 83, 0, 1988, 1989, + 5, 483, 0, 0, 1989, 1991, 3, 166, 83, 0, 1990, 1988, 1, 0, 0, 0, 1991, + 1994, 1, 0, 0, 0, 1992, 1990, 1, 0, 0, 0, 1992, 1993, 1, 0, 0, 0, 1993, + 165, 1, 0, 0, 0, 1994, 1992, 1, 0, 0, 0, 1995, 1996, 3, 176, 88, 0, 1996, + 1997, 5, 491, 0, 0, 1997, 1999, 3, 102, 51, 0, 1998, 2000, 5, 7, 0, 0, + 1999, 1998, 1, 0, 0, 0, 1999, 2000, 1, 0, 0, 0, 2000, 167, 1, 0, 0, 0, + 2001, 2002, 5, 76, 0, 0, 2002, 2003, 3, 102, 51, 0, 2003, 169, 1, 0, 0, + 0, 2004, 2005, 5, 358, 0, 0, 2005, 2006, 5, 75, 0, 0, 2006, 2007, 5, 499, + 0, 0, 2007, 2008, 5, 284, 0, 0, 2008, 2009, 5, 499, 0, 0, 2009, 171, 1, + 0, 0, 0, 2010, 2015, 3, 174, 87, 0, 2011, 2012, 5, 483, 0, 0, 2012, 2014, + 3, 174, 87, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2017, 1, 0, 0, 0, 2015, 2013, + 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 173, 1, 0, 0, 0, 2017, 2015, + 1, 0, 0, 0, 2018, 2021, 3, 176, 88, 0, 2019, 2021, 5, 502, 0, 0, 2020, + 2018, 1, 0, 0, 0, 2020, 2019, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, + 2023, 5, 491, 0, 0, 2023, 2024, 3, 102, 51, 0, 2024, 175, 1, 0, 0, 0, 2025, + 2029, 5, 503, 0, 0, 2026, 2029, 5, 505, 0, 0, 2027, 2029, 3, 706, 353, + 0, 2028, 2025, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2028, 2027, 1, 0, 0, + 0, 2029, 177, 1, 0, 0, 0, 2030, 2031, 5, 76, 0, 0, 2031, 2034, 3, 102, + 51, 0, 2032, 2033, 5, 75, 0, 0, 2033, 2035, 5, 502, 0, 0, 2034, 2032, 1, + 0, 0, 0, 2034, 2035, 1, 0, 0, 0, 2035, 179, 1, 0, 0, 0, 2036, 2038, 3, + 182, 91, 0, 2037, 2036, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 2037, + 1, 0, 0, 0, 2039, 2040, 1, 0, 0, 0, 2040, 181, 1, 0, 0, 0, 2041, 2042, + 5, 215, 0, 0, 2042, 2046, 5, 499, 0, 0, 2043, 2044, 5, 394, 0, 0, 2044, + 2046, 5, 499, 0, 0, 2045, 2041, 1, 0, 0, 0, 2045, 2043, 1, 0, 0, 0, 2046, + 183, 1, 0, 0, 0, 2047, 2049, 3, 186, 93, 0, 2048, 2047, 1, 0, 0, 0, 2049, + 2052, 1, 0, 0, 0, 2050, 2048, 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, + 185, 1, 0, 0, 0, 2052, 2050, 1, 0, 0, 0, 2053, 2055, 3, 696, 348, 0, 2054, + 2053, 1, 0, 0, 0, 2055, 2058, 1, 0, 0, 0, 2056, 2054, 1, 0, 0, 0, 2056, + 2057, 1, 0, 0, 0, 2057, 2059, 1, 0, 0, 0, 2058, 2056, 1, 0, 0, 0, 2059, + 2061, 3, 188, 94, 0, 2060, 2062, 5, 482, 0, 0, 2061, 2060, 1, 0, 0, 0, + 2061, 2062, 1, 0, 0, 0, 2062, 2374, 1, 0, 0, 0, 2063, 2065, 3, 696, 348, + 0, 2064, 2063, 1, 0, 0, 0, 2065, 2068, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, + 0, 2066, 2067, 1, 0, 0, 0, 2067, 2069, 1, 0, 0, 0, 2068, 2066, 1, 0, 0, + 0, 2069, 2071, 3, 190, 95, 0, 2070, 2072, 5, 482, 0, 0, 2071, 2070, 1, + 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2374, 1, 0, 0, 0, 2073, 2075, 3, + 696, 348, 0, 2074, 2073, 1, 0, 0, 0, 2075, 2078, 1, 0, 0, 0, 2076, 2074, + 1, 0, 0, 0, 2076, 2077, 1, 0, 0, 0, 2077, 2079, 1, 0, 0, 0, 2078, 2076, + 1, 0, 0, 0, 2079, 2081, 3, 294, 147, 0, 2080, 2082, 5, 482, 0, 0, 2081, + 2080, 1, 0, 0, 0, 2081, 2082, 1, 0, 0, 0, 2082, 2374, 1, 0, 0, 0, 2083, + 2085, 3, 696, 348, 0, 2084, 2083, 1, 0, 0, 0, 2085, 2088, 1, 0, 0, 0, 2086, + 2084, 1, 0, 0, 0, 2086, 2087, 1, 0, 0, 0, 2087, 2089, 1, 0, 0, 0, 2088, + 2086, 1, 0, 0, 0, 2089, 2091, 3, 192, 96, 0, 2090, 2092, 5, 482, 0, 0, + 2091, 2090, 1, 0, 0, 0, 2091, 2092, 1, 0, 0, 0, 2092, 2374, 1, 0, 0, 0, + 2093, 2095, 3, 696, 348, 0, 2094, 2093, 1, 0, 0, 0, 2095, 2098, 1, 0, 0, + 0, 2096, 2094, 1, 0, 0, 0, 2096, 2097, 1, 0, 0, 0, 2097, 2099, 1, 0, 0, + 0, 2098, 2096, 1, 0, 0, 0, 2099, 2101, 3, 194, 97, 0, 2100, 2102, 5, 482, + 0, 0, 2101, 2100, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2374, 1, 0, + 0, 0, 2103, 2105, 3, 696, 348, 0, 2104, 2103, 1, 0, 0, 0, 2105, 2108, 1, + 0, 0, 0, 2106, 2104, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2109, 1, + 0, 0, 0, 2108, 2106, 1, 0, 0, 0, 2109, 2111, 3, 198, 99, 0, 2110, 2112, + 5, 482, 0, 0, 2111, 2110, 1, 0, 0, 0, 2111, 2112, 1, 0, 0, 0, 2112, 2374, + 1, 0, 0, 0, 2113, 2115, 3, 696, 348, 0, 2114, 2113, 1, 0, 0, 0, 2115, 2118, + 1, 0, 0, 0, 2116, 2114, 1, 0, 0, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2119, + 1, 0, 0, 0, 2118, 2116, 1, 0, 0, 0, 2119, 2121, 3, 200, 100, 0, 2120, 2122, + 5, 482, 0, 0, 2121, 2120, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 2374, + 1, 0, 0, 0, 2123, 2125, 3, 696, 348, 0, 2124, 2123, 1, 0, 0, 0, 2125, 2128, + 1, 0, 0, 0, 2126, 2124, 1, 0, 0, 0, 2126, 2127, 1, 0, 0, 0, 2127, 2129, + 1, 0, 0, 0, 2128, 2126, 1, 0, 0, 0, 2129, 2131, 3, 202, 101, 0, 2130, 2132, + 5, 482, 0, 0, 2131, 2130, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2374, + 1, 0, 0, 0, 2133, 2135, 3, 696, 348, 0, 2134, 2133, 1, 0, 0, 0, 2135, 2138, + 1, 0, 0, 0, 2136, 2134, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2139, + 1, 0, 0, 0, 2138, 2136, 1, 0, 0, 0, 2139, 2141, 3, 204, 102, 0, 2140, 2142, + 5, 482, 0, 0, 2141, 2140, 1, 0, 0, 0, 2141, 2142, 1, 0, 0, 0, 2142, 2374, + 1, 0, 0, 0, 2143, 2145, 3, 696, 348, 0, 2144, 2143, 1, 0, 0, 0, 2145, 2148, + 1, 0, 0, 0, 2146, 2144, 1, 0, 0, 0, 2146, 2147, 1, 0, 0, 0, 2147, 2149, + 1, 0, 0, 0, 2148, 2146, 1, 0, 0, 0, 2149, 2151, 3, 210, 105, 0, 2150, 2152, + 5, 482, 0, 0, 2151, 2150, 1, 0, 0, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2374, + 1, 0, 0, 0, 2153, 2155, 3, 696, 348, 0, 2154, 2153, 1, 0, 0, 0, 2155, 2158, + 1, 0, 0, 0, 2156, 2154, 1, 0, 0, 0, 2156, 2157, 1, 0, 0, 0, 2157, 2159, + 1, 0, 0, 0, 2158, 2156, 1, 0, 0, 0, 2159, 2161, 3, 212, 106, 0, 2160, 2162, + 5, 482, 0, 0, 2161, 2160, 1, 0, 0, 0, 2161, 2162, 1, 0, 0, 0, 2162, 2374, + 1, 0, 0, 0, 2163, 2165, 3, 696, 348, 0, 2164, 2163, 1, 0, 0, 0, 2165, 2168, + 1, 0, 0, 0, 2166, 2164, 1, 0, 0, 0, 2166, 2167, 1, 0, 0, 0, 2167, 2169, + 1, 0, 0, 0, 2168, 2166, 1, 0, 0, 0, 2169, 2171, 3, 214, 107, 0, 2170, 2172, + 5, 482, 0, 0, 2171, 2170, 1, 0, 0, 0, 2171, 2172, 1, 0, 0, 0, 2172, 2374, + 1, 0, 0, 0, 2173, 2175, 3, 696, 348, 0, 2174, 2173, 1, 0, 0, 0, 2175, 2178, + 1, 0, 0, 0, 2176, 2174, 1, 0, 0, 0, 2176, 2177, 1, 0, 0, 0, 2177, 2179, + 1, 0, 0, 0, 2178, 2176, 1, 0, 0, 0, 2179, 2181, 3, 216, 108, 0, 2180, 2182, + 5, 482, 0, 0, 2181, 2180, 1, 0, 0, 0, 2181, 2182, 1, 0, 0, 0, 2182, 2374, + 1, 0, 0, 0, 2183, 2185, 3, 696, 348, 0, 2184, 2183, 1, 0, 0, 0, 2185, 2188, + 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2186, 2187, 1, 0, 0, 0, 2187, 2189, + 1, 0, 0, 0, 2188, 2186, 1, 0, 0, 0, 2189, 2191, 3, 218, 109, 0, 2190, 2192, + 5, 482, 0, 0, 2191, 2190, 1, 0, 0, 0, 2191, 2192, 1, 0, 0, 0, 2192, 2374, + 1, 0, 0, 0, 2193, 2195, 3, 696, 348, 0, 2194, 2193, 1, 0, 0, 0, 2195, 2198, + 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2196, 2197, 1, 0, 0, 0, 2197, 2199, + 1, 0, 0, 0, 2198, 2196, 1, 0, 0, 0, 2199, 2201, 3, 220, 110, 0, 2200, 2202, + 5, 482, 0, 0, 2201, 2200, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2374, + 1, 0, 0, 0, 2203, 2205, 3, 696, 348, 0, 2204, 2203, 1, 0, 0, 0, 2205, 2208, + 1, 0, 0, 0, 2206, 2204, 1, 0, 0, 0, 2206, 2207, 1, 0, 0, 0, 2207, 2209, + 1, 0, 0, 0, 2208, 2206, 1, 0, 0, 0, 2209, 2211, 3, 222, 111, 0, 2210, 2212, + 5, 482, 0, 0, 2211, 2210, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2374, + 1, 0, 0, 0, 2213, 2215, 3, 696, 348, 0, 2214, 2213, 1, 0, 0, 0, 2215, 2218, + 1, 0, 0, 0, 2216, 2214, 1, 0, 0, 0, 2216, 2217, 1, 0, 0, 0, 2217, 2219, + 1, 0, 0, 0, 2218, 2216, 1, 0, 0, 0, 2219, 2221, 3, 224, 112, 0, 2220, 2222, + 5, 482, 0, 0, 2221, 2220, 1, 0, 0, 0, 2221, 2222, 1, 0, 0, 0, 2222, 2374, + 1, 0, 0, 0, 2223, 2225, 3, 696, 348, 0, 2224, 2223, 1, 0, 0, 0, 2225, 2228, + 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2229, + 1, 0, 0, 0, 2228, 2226, 1, 0, 0, 0, 2229, 2231, 3, 236, 118, 0, 2230, 2232, + 5, 482, 0, 0, 2231, 2230, 1, 0, 0, 0, 2231, 2232, 1, 0, 0, 0, 2232, 2374, + 1, 0, 0, 0, 2233, 2235, 3, 696, 348, 0, 2234, 2233, 1, 0, 0, 0, 2235, 2238, + 1, 0, 0, 0, 2236, 2234, 1, 0, 0, 0, 2236, 2237, 1, 0, 0, 0, 2237, 2239, + 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2239, 2241, 3, 238, 119, 0, 2240, 2242, + 5, 482, 0, 0, 2241, 2240, 1, 0, 0, 0, 2241, 2242, 1, 0, 0, 0, 2242, 2374, + 1, 0, 0, 0, 2243, 2245, 3, 696, 348, 0, 2244, 2243, 1, 0, 0, 0, 2245, 2248, + 1, 0, 0, 0, 2246, 2244, 1, 0, 0, 0, 2246, 2247, 1, 0, 0, 0, 2247, 2249, + 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2249, 2251, 3, 240, 120, 0, 2250, 2252, + 5, 482, 0, 0, 2251, 2250, 1, 0, 0, 0, 2251, 2252, 1, 0, 0, 0, 2252, 2374, + 1, 0, 0, 0, 2253, 2255, 3, 696, 348, 0, 2254, 2253, 1, 0, 0, 0, 2255, 2258, + 1, 0, 0, 0, 2256, 2254, 1, 0, 0, 0, 2256, 2257, 1, 0, 0, 0, 2257, 2259, + 1, 0, 0, 0, 2258, 2256, 1, 0, 0, 0, 2259, 2261, 3, 242, 121, 0, 2260, 2262, + 5, 482, 0, 0, 2261, 2260, 1, 0, 0, 0, 2261, 2262, 1, 0, 0, 0, 2262, 2374, + 1, 0, 0, 0, 2263, 2265, 3, 696, 348, 0, 2264, 2263, 1, 0, 0, 0, 2265, 2268, + 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2266, 2267, 1, 0, 0, 0, 2267, 2269, + 1, 0, 0, 0, 2268, 2266, 1, 0, 0, 0, 2269, 2271, 3, 248, 124, 0, 2270, 2272, + 5, 482, 0, 0, 2271, 2270, 1, 0, 0, 0, 2271, 2272, 1, 0, 0, 0, 2272, 2374, + 1, 0, 0, 0, 2273, 2275, 3, 696, 348, 0, 2274, 2273, 1, 0, 0, 0, 2275, 2278, + 1, 0, 0, 0, 2276, 2274, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 2279, + 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2279, 2281, 3, 254, 127, 0, 2280, 2282, + 5, 482, 0, 0, 2281, 2280, 1, 0, 0, 0, 2281, 2282, 1, 0, 0, 0, 2282, 2374, + 1, 0, 0, 0, 2283, 2285, 3, 696, 348, 0, 2284, 2283, 1, 0, 0, 0, 2285, 2288, + 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2286, 2287, 1, 0, 0, 0, 2287, 2289, + 1, 0, 0, 0, 2288, 2286, 1, 0, 0, 0, 2289, 2291, 3, 256, 128, 0, 2290, 2292, + 5, 482, 0, 0, 2291, 2290, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, 2374, + 1, 0, 0, 0, 2293, 2295, 3, 696, 348, 0, 2294, 2293, 1, 0, 0, 0, 2295, 2298, + 1, 0, 0, 0, 2296, 2294, 1, 0, 0, 0, 2296, 2297, 1, 0, 0, 0, 2297, 2299, + 1, 0, 0, 0, 2298, 2296, 1, 0, 0, 0, 2299, 2301, 3, 258, 129, 0, 2300, 2302, + 5, 482, 0, 0, 2301, 2300, 1, 0, 0, 0, 2301, 2302, 1, 0, 0, 0, 2302, 2374, + 1, 0, 0, 0, 2303, 2305, 3, 696, 348, 0, 2304, 2303, 1, 0, 0, 0, 2305, 2308, + 1, 0, 0, 0, 2306, 2304, 1, 0, 0, 0, 2306, 2307, 1, 0, 0, 0, 2307, 2309, + 1, 0, 0, 0, 2308, 2306, 1, 0, 0, 0, 2309, 2311, 3, 260, 130, 0, 2310, 2312, + 5, 482, 0, 0, 2311, 2310, 1, 0, 0, 0, 2311, 2312, 1, 0, 0, 0, 2312, 2374, + 1, 0, 0, 0, 2313, 2315, 3, 696, 348, 0, 2314, 2313, 1, 0, 0, 0, 2315, 2318, + 1, 0, 0, 0, 2316, 2314, 1, 0, 0, 0, 2316, 2317, 1, 0, 0, 0, 2317, 2319, + 1, 0, 0, 0, 2318, 2316, 1, 0, 0, 0, 2319, 2321, 3, 282, 141, 0, 2320, 2322, + 5, 482, 0, 0, 2321, 2320, 1, 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2374, + 1, 0, 0, 0, 2323, 2325, 3, 696, 348, 0, 2324, 2323, 1, 0, 0, 0, 2325, 2328, + 1, 0, 0, 0, 2326, 2324, 1, 0, 0, 0, 2326, 2327, 1, 0, 0, 0, 2327, 2329, + 1, 0, 0, 0, 2328, 2326, 1, 0, 0, 0, 2329, 2331, 3, 290, 145, 0, 2330, 2332, + 5, 482, 0, 0, 2331, 2330, 1, 0, 0, 0, 2331, 2332, 1, 0, 0, 0, 2332, 2374, + 1, 0, 0, 0, 2333, 2335, 3, 696, 348, 0, 2334, 2333, 1, 0, 0, 0, 2335, 2338, + 1, 0, 0, 0, 2336, 2334, 1, 0, 0, 0, 2336, 2337, 1, 0, 0, 0, 2337, 2339, + 1, 0, 0, 0, 2338, 2336, 1, 0, 0, 0, 2339, 2341, 3, 296, 148, 0, 2340, 2342, + 5, 482, 0, 0, 2341, 2340, 1, 0, 0, 0, 2341, 2342, 1, 0, 0, 0, 2342, 2374, + 1, 0, 0, 0, 2343, 2345, 3, 696, 348, 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, 2351, 3, 298, 149, 0, 2350, 2352, + 5, 482, 0, 0, 2351, 2350, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2374, + 1, 0, 0, 0, 2353, 2355, 3, 696, 348, 0, 2354, 2353, 1, 0, 0, 0, 2355, 2358, + 1, 0, 0, 0, 2356, 2354, 1, 0, 0, 0, 2356, 2357, 1, 0, 0, 0, 2357, 2359, + 1, 0, 0, 0, 2358, 2356, 1, 0, 0, 0, 2359, 2361, 3, 262, 131, 0, 2360, 2362, + 5, 482, 0, 0, 2361, 2360, 1, 0, 0, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2374, + 1, 0, 0, 0, 2363, 2365, 3, 696, 348, 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, 2371, 3, 264, 132, 0, 2370, 2372, + 5, 482, 0, 0, 2371, 2370, 1, 0, 0, 0, 2371, 2372, 1, 0, 0, 0, 2372, 2374, + 1, 0, 0, 0, 2373, 2056, 1, 0, 0, 0, 2373, 2066, 1, 0, 0, 0, 2373, 2076, + 1, 0, 0, 0, 2373, 2086, 1, 0, 0, 0, 2373, 2096, 1, 0, 0, 0, 2373, 2106, + 1, 0, 0, 0, 2373, 2116, 1, 0, 0, 0, 2373, 2126, 1, 0, 0, 0, 2373, 2136, + 1, 0, 0, 0, 2373, 2146, 1, 0, 0, 0, 2373, 2156, 1, 0, 0, 0, 2373, 2166, + 1, 0, 0, 0, 2373, 2176, 1, 0, 0, 0, 2373, 2186, 1, 0, 0, 0, 2373, 2196, + 1, 0, 0, 0, 2373, 2206, 1, 0, 0, 0, 2373, 2216, 1, 0, 0, 0, 2373, 2226, + 1, 0, 0, 0, 2373, 2236, 1, 0, 0, 0, 2373, 2246, 1, 0, 0, 0, 2373, 2256, + 1, 0, 0, 0, 2373, 2266, 1, 0, 0, 0, 2373, 2276, 1, 0, 0, 0, 2373, 2286, + 1, 0, 0, 0, 2373, 2296, 1, 0, 0, 0, 2373, 2306, 1, 0, 0, 0, 2373, 2316, + 1, 0, 0, 0, 2373, 2326, 1, 0, 0, 0, 2373, 2336, 1, 0, 0, 0, 2373, 2346, + 1, 0, 0, 0, 2373, 2356, 1, 0, 0, 0, 2373, 2366, 1, 0, 0, 0, 2374, 187, + 1, 0, 0, 0, 2375, 2376, 5, 96, 0, 0, 2376, 2377, 5, 502, 0, 0, 2377, 2380, + 3, 102, 51, 0, 2378, 2379, 5, 472, 0, 0, 2379, 2381, 3, 646, 323, 0, 2380, + 2378, 1, 0, 0, 0, 2380, 2381, 1, 0, 0, 0, 2381, 189, 1, 0, 0, 0, 2382, + 2385, 5, 47, 0, 0, 2383, 2386, 5, 502, 0, 0, 2384, 2386, 3, 196, 98, 0, + 2385, 2383, 1, 0, 0, 0, 2385, 2384, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, + 2387, 2388, 5, 472, 0, 0, 2388, 2389, 3, 646, 323, 0, 2389, 191, 1, 0, + 0, 0, 2390, 2391, 5, 502, 0, 0, 2391, 2393, 5, 472, 0, 0, 2392, 2390, 1, + 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2395, 5, + 17, 0, 0, 2395, 2401, 3, 106, 53, 0, 2396, 2398, 5, 485, 0, 0, 2397, 2399, + 3, 300, 150, 0, 2398, 2397, 1, 0, 0, 0, 2398, 2399, 1, 0, 0, 0, 2399, 2400, + 1, 0, 0, 0, 2400, 2402, 5, 486, 0, 0, 2401, 2396, 1, 0, 0, 0, 2401, 2402, + 1, 0, 0, 0, 2402, 2404, 1, 0, 0, 0, 2403, 2405, 3, 208, 104, 0, 2404, 2403, + 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 193, 1, 0, 0, 0, 2406, 2407, + 5, 97, 0, 0, 2407, 2413, 5, 502, 0, 0, 2408, 2410, 5, 485, 0, 0, 2409, + 2411, 3, 300, 150, 0, 2410, 2409, 1, 0, 0, 0, 2410, 2411, 1, 0, 0, 0, 2411, + 2412, 1, 0, 0, 0, 2412, 2414, 5, 486, 0, 0, 2413, 2408, 1, 0, 0, 0, 2413, + 2414, 1, 0, 0, 0, 2414, 195, 1, 0, 0, 0, 2415, 2421, 5, 502, 0, 0, 2416, + 2419, 7, 11, 0, 0, 2417, 2420, 5, 503, 0, 0, 2418, 2420, 3, 684, 342, 0, + 2419, 2417, 1, 0, 0, 0, 2419, 2418, 1, 0, 0, 0, 2420, 2422, 1, 0, 0, 0, + 2421, 2416, 1, 0, 0, 0, 2422, 2423, 1, 0, 0, 0, 2423, 2421, 1, 0, 0, 0, + 2423, 2424, 1, 0, 0, 0, 2424, 197, 1, 0, 0, 0, 2425, 2426, 5, 100, 0, 0, + 2426, 2429, 5, 502, 0, 0, 2427, 2428, 5, 137, 0, 0, 2428, 2430, 5, 118, + 0, 0, 2429, 2427, 1, 0, 0, 0, 2429, 2430, 1, 0, 0, 0, 2430, 2432, 1, 0, + 0, 0, 2431, 2433, 5, 384, 0, 0, 2432, 2431, 1, 0, 0, 0, 2432, 2433, 1, + 0, 0, 0, 2433, 2435, 1, 0, 0, 0, 2434, 2436, 3, 208, 104, 0, 2435, 2434, + 1, 0, 0, 0, 2435, 2436, 1, 0, 0, 0, 2436, 199, 1, 0, 0, 0, 2437, 2438, + 5, 99, 0, 0, 2438, 2440, 5, 502, 0, 0, 2439, 2441, 3, 208, 104, 0, 2440, + 2439, 1, 0, 0, 0, 2440, 2441, 1, 0, 0, 0, 2441, 201, 1, 0, 0, 0, 2442, + 2443, 5, 101, 0, 0, 2443, 2445, 5, 502, 0, 0, 2444, 2446, 5, 384, 0, 0, + 2445, 2444, 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 203, 1, 0, 0, 0, + 2447, 2448, 5, 98, 0, 0, 2448, 2449, 5, 502, 0, 0, 2449, 2450, 5, 70, 0, + 0, 2450, 2456, 3, 206, 103, 0, 2451, 2454, 5, 71, 0, 0, 2452, 2455, 3, + 332, 166, 0, 2453, 2455, 3, 646, 323, 0, 2454, 2452, 1, 0, 0, 0, 2454, + 2453, 1, 0, 0, 0, 2455, 2457, 1, 0, 0, 0, 2456, 2451, 1, 0, 0, 0, 2456, + 2457, 1, 0, 0, 0, 2457, 2467, 1, 0, 0, 0, 2458, 2459, 5, 10, 0, 0, 2459, + 2464, 3, 330, 165, 0, 2460, 2461, 5, 483, 0, 0, 2461, 2463, 3, 330, 165, + 0, 2462, 2460, 1, 0, 0, 0, 2463, 2466, 1, 0, 0, 0, 2464, 2462, 1, 0, 0, + 0, 2464, 2465, 1, 0, 0, 0, 2465, 2468, 1, 0, 0, 0, 2466, 2464, 1, 0, 0, + 0, 2467, 2458, 1, 0, 0, 0, 2467, 2468, 1, 0, 0, 0, 2468, 2471, 1, 0, 0, + 0, 2469, 2470, 5, 74, 0, 0, 2470, 2472, 3, 646, 323, 0, 2471, 2469, 1, + 0, 0, 0, 2471, 2472, 1, 0, 0, 0, 2472, 2475, 1, 0, 0, 0, 2473, 2474, 5, + 73, 0, 0, 2474, 2476, 3, 646, 323, 0, 2475, 2473, 1, 0, 0, 0, 2475, 2476, + 1, 0, 0, 0, 2476, 2478, 1, 0, 0, 0, 2477, 2479, 3, 208, 104, 0, 2478, 2477, + 1, 0, 0, 0, 2478, 2479, 1, 0, 0, 0, 2479, 205, 1, 0, 0, 0, 2480, 2488, + 3, 684, 342, 0, 2481, 2482, 5, 485, 0, 0, 2482, 2483, 3, 560, 280, 0, 2483, + 2484, 5, 486, 0, 0, 2484, 2488, 1, 0, 0, 0, 2485, 2486, 5, 344, 0, 0, 2486, + 2488, 5, 499, 0, 0, 2487, 2480, 1, 0, 0, 0, 2487, 2481, 1, 0, 0, 0, 2487, + 2485, 1, 0, 0, 0, 2488, 207, 1, 0, 0, 0, 2489, 2490, 5, 92, 0, 0, 2490, + 2491, 5, 297, 0, 0, 2491, 2510, 5, 107, 0, 0, 2492, 2493, 5, 92, 0, 0, + 2493, 2494, 5, 297, 0, 0, 2494, 2510, 5, 101, 0, 0, 2495, 2496, 5, 92, + 0, 0, 2496, 2497, 5, 297, 0, 0, 2497, 2498, 5, 487, 0, 0, 2498, 2499, 3, + 184, 92, 0, 2499, 2500, 5, 488, 0, 0, 2500, 2510, 1, 0, 0, 0, 2501, 2502, + 5, 92, 0, 0, 2502, 2503, 5, 297, 0, 0, 2503, 2504, 5, 420, 0, 0, 2504, + 2505, 5, 101, 0, 0, 2505, 2506, 5, 487, 0, 0, 2506, 2507, 3, 184, 92, 0, + 2507, 2508, 5, 488, 0, 0, 2508, 2510, 1, 0, 0, 0, 2509, 2489, 1, 0, 0, + 0, 2509, 2492, 1, 0, 0, 0, 2509, 2495, 1, 0, 0, 0, 2509, 2501, 1, 0, 0, + 0, 2510, 209, 1, 0, 0, 0, 2511, 2512, 5, 104, 0, 0, 2512, 2513, 3, 646, + 323, 0, 2513, 2514, 5, 80, 0, 0, 2514, 2522, 3, 184, 92, 0, 2515, 2516, + 5, 105, 0, 0, 2516, 2517, 3, 646, 323, 0, 2517, 2518, 5, 80, 0, 0, 2518, + 2519, 3, 184, 92, 0, 2519, 2521, 1, 0, 0, 0, 2520, 2515, 1, 0, 0, 0, 2521, + 2524, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2522, 2523, 1, 0, 0, 0, 2523, + 2527, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2525, 2526, 5, 81, 0, 0, 2526, + 2528, 3, 184, 92, 0, 2527, 2525, 1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, + 2529, 1, 0, 0, 0, 2529, 2530, 5, 82, 0, 0, 2530, 2531, 5, 104, 0, 0, 2531, + 211, 1, 0, 0, 0, 2532, 2533, 5, 102, 0, 0, 2533, 2534, 5, 502, 0, 0, 2534, + 2537, 5, 284, 0, 0, 2535, 2538, 5, 502, 0, 0, 2536, 2538, 3, 196, 98, 0, + 2537, 2535, 1, 0, 0, 0, 2537, 2536, 1, 0, 0, 0, 2538, 2539, 1, 0, 0, 0, + 2539, 2540, 5, 95, 0, 0, 2540, 2541, 3, 184, 92, 0, 2541, 2542, 5, 82, + 0, 0, 2542, 2543, 5, 102, 0, 0, 2543, 213, 1, 0, 0, 0, 2544, 2545, 5, 103, + 0, 0, 2545, 2547, 3, 646, 323, 0, 2546, 2548, 5, 95, 0, 0, 2547, 2546, + 1, 0, 0, 0, 2547, 2548, 1, 0, 0, 0, 2548, 2549, 1, 0, 0, 0, 2549, 2550, + 3, 184, 92, 0, 2550, 2552, 5, 82, 0, 0, 2551, 2553, 5, 103, 0, 0, 2552, + 2551, 1, 0, 0, 0, 2552, 2553, 1, 0, 0, 0, 2553, 215, 1, 0, 0, 0, 2554, + 2555, 5, 107, 0, 0, 2555, 217, 1, 0, 0, 0, 2556, 2557, 5, 108, 0, 0, 2557, + 219, 1, 0, 0, 0, 2558, 2560, 5, 109, 0, 0, 2559, 2561, 3, 646, 323, 0, + 2560, 2559, 1, 0, 0, 0, 2560, 2561, 1, 0, 0, 0, 2561, 221, 1, 0, 0, 0, + 2562, 2563, 5, 298, 0, 0, 2563, 2564, 5, 297, 0, 0, 2564, 223, 1, 0, 0, + 0, 2565, 2567, 5, 111, 0, 0, 2566, 2568, 3, 226, 113, 0, 2567, 2566, 1, + 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2571, 1, 0, 0, 0, 2569, 2570, 5, + 117, 0, 0, 2570, 2572, 5, 499, 0, 0, 2571, 2569, 1, 0, 0, 0, 2571, 2572, + 1, 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2575, 3, 646, 323, 0, 2574, 2576, + 3, 232, 116, 0, 2575, 2574, 1, 0, 0, 0, 2575, 2576, 1, 0, 0, 0, 2576, 225, + 1, 0, 0, 0, 2577, 2578, 7, 12, 0, 0, 2578, 227, 1, 0, 0, 0, 2579, 2580, + 5, 137, 0, 0, 2580, 2581, 5, 485, 0, 0, 2581, 2586, 3, 230, 115, 0, 2582, + 2583, 5, 483, 0, 0, 2583, 2585, 3, 230, 115, 0, 2584, 2582, 1, 0, 0, 0, + 2585, 2588, 1, 0, 0, 0, 2586, 2584, 1, 0, 0, 0, 2586, 2587, 1, 0, 0, 0, + 2587, 2589, 1, 0, 0, 0, 2588, 2586, 1, 0, 0, 0, 2589, 2590, 5, 486, 0, + 0, 2590, 2594, 1, 0, 0, 0, 2591, 2592, 5, 360, 0, 0, 2592, 2594, 3, 690, + 345, 0, 2593, 2579, 1, 0, 0, 0, 2593, 2591, 1, 0, 0, 0, 2594, 229, 1, 0, + 0, 0, 2595, 2596, 5, 487, 0, 0, 2596, 2597, 5, 501, 0, 0, 2597, 2598, 5, + 488, 0, 0, 2598, 2599, 5, 472, 0, 0, 2599, 2600, 3, 646, 323, 0, 2600, + 231, 1, 0, 0, 0, 2601, 2602, 3, 228, 114, 0, 2602, 233, 1, 0, 0, 0, 2603, + 2604, 3, 230, 115, 0, 2604, 235, 1, 0, 0, 0, 2605, 2606, 5, 502, 0, 0, + 2606, 2608, 5, 472, 0, 0, 2607, 2605, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, + 0, 2608, 2609, 1, 0, 0, 0, 2609, 2610, 5, 112, 0, 0, 2610, 2611, 5, 30, + 0, 0, 2611, 2612, 3, 684, 342, 0, 2612, 2614, 5, 485, 0, 0, 2613, 2615, + 3, 244, 122, 0, 2614, 2613, 1, 0, 0, 0, 2614, 2615, 1, 0, 0, 0, 2615, 2616, + 1, 0, 0, 0, 2616, 2618, 5, 486, 0, 0, 2617, 2619, 3, 208, 104, 0, 2618, + 2617, 1, 0, 0, 0, 2618, 2619, 1, 0, 0, 0, 2619, 237, 1, 0, 0, 0, 2620, + 2621, 5, 502, 0, 0, 2621, 2623, 5, 472, 0, 0, 2622, 2620, 1, 0, 0, 0, 2622, + 2623, 1, 0, 0, 0, 2623, 2624, 1, 0, 0, 0, 2624, 2625, 5, 112, 0, 0, 2625, + 2626, 5, 113, 0, 0, 2626, 2627, 5, 114, 0, 0, 2627, 2628, 3, 684, 342, + 0, 2628, 2630, 5, 485, 0, 0, 2629, 2631, 3, 244, 122, 0, 2630, 2629, 1, + 0, 0, 0, 2630, 2631, 1, 0, 0, 0, 2631, 2632, 1, 0, 0, 0, 2632, 2634, 5, + 486, 0, 0, 2633, 2635, 3, 208, 104, 0, 2634, 2633, 1, 0, 0, 0, 2634, 2635, + 1, 0, 0, 0, 2635, 239, 1, 0, 0, 0, 2636, 2637, 5, 502, 0, 0, 2637, 2639, + 5, 472, 0, 0, 2638, 2636, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2640, + 1, 0, 0, 0, 2640, 2641, 5, 387, 0, 0, 2641, 2642, 5, 344, 0, 0, 2642, 2643, + 5, 345, 0, 0, 2643, 2650, 3, 684, 342, 0, 2644, 2648, 5, 164, 0, 0, 2645, + 2649, 5, 499, 0, 0, 2646, 2649, 5, 500, 0, 0, 2647, 2649, 3, 646, 323, + 0, 2648, 2645, 1, 0, 0, 0, 2648, 2646, 1, 0, 0, 0, 2648, 2647, 1, 0, 0, + 0, 2649, 2651, 1, 0, 0, 0, 2650, 2644, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, + 0, 2651, 2657, 1, 0, 0, 0, 2652, 2654, 5, 485, 0, 0, 2653, 2655, 3, 244, + 122, 0, 2654, 2653, 1, 0, 0, 0, 2654, 2655, 1, 0, 0, 0, 2655, 2656, 1, + 0, 0, 0, 2656, 2658, 5, 486, 0, 0, 2657, 2652, 1, 0, 0, 0, 2657, 2658, + 1, 0, 0, 0, 2658, 2665, 1, 0, 0, 0, 2659, 2660, 5, 343, 0, 0, 2660, 2662, + 5, 485, 0, 0, 2661, 2663, 3, 244, 122, 0, 2662, 2661, 1, 0, 0, 0, 2662, + 2663, 1, 0, 0, 0, 2663, 2664, 1, 0, 0, 0, 2664, 2666, 5, 486, 0, 0, 2665, + 2659, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2668, 1, 0, 0, 0, 2667, + 2669, 3, 208, 104, 0, 2668, 2667, 1, 0, 0, 0, 2668, 2669, 1, 0, 0, 0, 2669, + 241, 1, 0, 0, 0, 2670, 2671, 5, 502, 0, 0, 2671, 2673, 5, 472, 0, 0, 2672, + 2670, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, 2674, 1, 0, 0, 0, 2674, + 2675, 5, 112, 0, 0, 2675, 2676, 5, 26, 0, 0, 2676, 2677, 5, 114, 0, 0, + 2677, 2678, 3, 684, 342, 0, 2678, 2680, 5, 485, 0, 0, 2679, 2681, 3, 244, + 122, 0, 2680, 2679, 1, 0, 0, 0, 2680, 2681, 1, 0, 0, 0, 2681, 2682, 1, + 0, 0, 0, 2682, 2684, 5, 486, 0, 0, 2683, 2685, 3, 208, 104, 0, 2684, 2683, + 1, 0, 0, 0, 2684, 2685, 1, 0, 0, 0, 2685, 243, 1, 0, 0, 0, 2686, 2691, + 3, 246, 123, 0, 2687, 2688, 5, 483, 0, 0, 2688, 2690, 3, 246, 123, 0, 2689, + 2687, 1, 0, 0, 0, 2690, 2693, 1, 0, 0, 0, 2691, 2689, 1, 0, 0, 0, 2691, + 2692, 1, 0, 0, 0, 2692, 245, 1, 0, 0, 0, 2693, 2691, 1, 0, 0, 0, 2694, + 2697, 5, 502, 0, 0, 2695, 2697, 3, 176, 88, 0, 2696, 2694, 1, 0, 0, 0, + 2696, 2695, 1, 0, 0, 0, 2697, 2698, 1, 0, 0, 0, 2698, 2699, 5, 472, 0, + 0, 2699, 2700, 3, 646, 323, 0, 2700, 247, 1, 0, 0, 0, 2701, 2702, 5, 64, + 0, 0, 2702, 2703, 5, 33, 0, 0, 2703, 2709, 3, 684, 342, 0, 2704, 2706, + 5, 485, 0, 0, 2705, 2707, 3, 250, 125, 0, 2706, 2705, 1, 0, 0, 0, 2706, + 2707, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 2710, 5, 486, 0, 0, 2709, + 2704, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, 0, 2710, 2713, 1, 0, 0, 0, 2711, + 2712, 5, 414, 0, 0, 2712, 2714, 5, 502, 0, 0, 2713, 2711, 1, 0, 0, 0, 2713, + 2714, 1, 0, 0, 0, 2714, 2717, 1, 0, 0, 0, 2715, 2716, 5, 137, 0, 0, 2716, + 2718, 3, 300, 150, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, + 249, 1, 0, 0, 0, 2719, 2724, 3, 252, 126, 0, 2720, 2721, 5, 483, 0, 0, + 2721, 2723, 3, 252, 126, 0, 2722, 2720, 1, 0, 0, 0, 2723, 2726, 1, 0, 0, + 0, 2724, 2722, 1, 0, 0, 0, 2724, 2725, 1, 0, 0, 0, 2725, 251, 1, 0, 0, + 0, 2726, 2724, 1, 0, 0, 0, 2727, 2728, 5, 502, 0, 0, 2728, 2731, 5, 472, + 0, 0, 2729, 2732, 5, 502, 0, 0, 2730, 2732, 3, 646, 323, 0, 2731, 2729, + 1, 0, 0, 0, 2731, 2730, 1, 0, 0, 0, 2732, 2738, 1, 0, 0, 0, 2733, 2734, + 3, 686, 343, 0, 2734, 2735, 5, 491, 0, 0, 2735, 2736, 3, 646, 323, 0, 2736, + 2738, 1, 0, 0, 0, 2737, 2727, 1, 0, 0, 0, 2737, 2733, 1, 0, 0, 0, 2738, + 253, 1, 0, 0, 0, 2739, 2740, 5, 116, 0, 0, 2740, 2741, 5, 33, 0, 0, 2741, + 255, 1, 0, 0, 0, 2742, 2743, 5, 64, 0, 0, 2743, 2744, 5, 365, 0, 0, 2744, + 2745, 5, 33, 0, 0, 2745, 257, 1, 0, 0, 0, 2746, 2747, 5, 64, 0, 0, 2747, + 2748, 5, 393, 0, 0, 2748, 2751, 3, 646, 323, 0, 2749, 2750, 5, 405, 0, + 0, 2750, 2752, 3, 686, 343, 0, 2751, 2749, 1, 0, 0, 0, 2751, 2752, 1, 0, + 0, 0, 2752, 2758, 1, 0, 0, 0, 2753, 2754, 5, 140, 0, 0, 2754, 2755, 5, + 489, 0, 0, 2755, 2756, 3, 682, 341, 0, 2756, 2757, 5, 490, 0, 0, 2757, + 2759, 1, 0, 0, 0, 2758, 2753, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, + 259, 1, 0, 0, 0, 2760, 2761, 5, 110, 0, 0, 2761, 2762, 3, 646, 323, 0, + 2762, 261, 1, 0, 0, 0, 2763, 2764, 5, 293, 0, 0, 2764, 2765, 5, 294, 0, + 0, 2765, 2766, 3, 196, 98, 0, 2766, 2767, 5, 393, 0, 0, 2767, 2773, 3, + 646, 323, 0, 2768, 2769, 5, 140, 0, 0, 2769, 2770, 5, 489, 0, 0, 2770, + 2771, 3, 682, 341, 0, 2771, 2772, 5, 490, 0, 0, 2772, 2774, 1, 0, 0, 0, + 2773, 2768, 1, 0, 0, 0, 2773, 2774, 1, 0, 0, 0, 2774, 263, 1, 0, 0, 0, + 2775, 2776, 5, 502, 0, 0, 2776, 2778, 5, 472, 0, 0, 2777, 2775, 1, 0, 0, + 0, 2777, 2778, 1, 0, 0, 0, 2778, 2779, 1, 0, 0, 0, 2779, 2780, 5, 306, + 0, 0, 2780, 2781, 5, 112, 0, 0, 2781, 2782, 3, 266, 133, 0, 2782, 2784, + 3, 268, 134, 0, 2783, 2785, 3, 270, 135, 0, 2784, 2783, 1, 0, 0, 0, 2784, + 2785, 1, 0, 0, 0, 2785, 2789, 1, 0, 0, 0, 2786, 2788, 3, 272, 136, 0, 2787, + 2786, 1, 0, 0, 0, 2788, 2791, 1, 0, 0, 0, 2789, 2787, 1, 0, 0, 0, 2789, + 2790, 1, 0, 0, 0, 2790, 2793, 1, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2792, + 2794, 3, 274, 137, 0, 2793, 2792, 1, 0, 0, 0, 2793, 2794, 1, 0, 0, 0, 2794, + 2796, 1, 0, 0, 0, 2795, 2797, 3, 276, 138, 0, 2796, 2795, 1, 0, 0, 0, 2796, + 2797, 1, 0, 0, 0, 2797, 2799, 1, 0, 0, 0, 2798, 2800, 3, 278, 139, 0, 2799, + 2798, 1, 0, 0, 0, 2799, 2800, 1, 0, 0, 0, 2800, 2801, 1, 0, 0, 0, 2801, + 2803, 3, 280, 140, 0, 2802, 2804, 3, 208, 104, 0, 2803, 2802, 1, 0, 0, + 0, 2803, 2804, 1, 0, 0, 0, 2804, 265, 1, 0, 0, 0, 2805, 2806, 7, 13, 0, + 0, 2806, 267, 1, 0, 0, 0, 2807, 2810, 5, 499, 0, 0, 2808, 2810, 3, 646, + 323, 0, 2809, 2807, 1, 0, 0, 0, 2809, 2808, 1, 0, 0, 0, 2810, 269, 1, 0, + 0, 0, 2811, 2812, 3, 228, 114, 0, 2812, 271, 1, 0, 0, 0, 2813, 2814, 5, + 193, 0, 0, 2814, 2815, 7, 14, 0, 0, 2815, 2816, 5, 472, 0, 0, 2816, 2817, + 3, 646, 323, 0, 2817, 273, 1, 0, 0, 0, 2818, 2819, 5, 311, 0, 0, 2819, + 2820, 5, 313, 0, 0, 2820, 2821, 3, 646, 323, 0, 2821, 2822, 5, 342, 0, + 0, 2822, 2823, 3, 646, 323, 0, 2823, 275, 1, 0, 0, 0, 2824, 2825, 5, 320, + 0, 0, 2825, 2827, 5, 499, 0, 0, 2826, 2828, 3, 228, 114, 0, 2827, 2826, + 1, 0, 0, 0, 2827, 2828, 1, 0, 0, 0, 2828, 2841, 1, 0, 0, 0, 2829, 2830, + 5, 320, 0, 0, 2830, 2832, 3, 646, 323, 0, 2831, 2833, 3, 228, 114, 0, 2832, + 2831, 1, 0, 0, 0, 2832, 2833, 1, 0, 0, 0, 2833, 2841, 1, 0, 0, 0, 2834, + 2835, 5, 320, 0, 0, 2835, 2836, 5, 347, 0, 0, 2836, 2837, 3, 684, 342, + 0, 2837, 2838, 5, 70, 0, 0, 2838, 2839, 5, 502, 0, 0, 2839, 2841, 1, 0, + 0, 0, 2840, 2824, 1, 0, 0, 0, 2840, 2829, 1, 0, 0, 0, 2840, 2834, 1, 0, + 0, 0, 2841, 277, 1, 0, 0, 0, 2842, 2843, 5, 319, 0, 0, 2843, 2844, 3, 646, + 323, 0, 2844, 279, 1, 0, 0, 0, 2845, 2846, 5, 76, 0, 0, 2846, 2860, 5, + 257, 0, 0, 2847, 2848, 5, 76, 0, 0, 2848, 2860, 5, 321, 0, 0, 2849, 2850, + 5, 76, 0, 0, 2850, 2851, 5, 347, 0, 0, 2851, 2852, 3, 684, 342, 0, 2852, + 2853, 5, 75, 0, 0, 2853, 2854, 3, 684, 342, 0, 2854, 2860, 1, 0, 0, 0, + 2855, 2856, 5, 76, 0, 0, 2856, 2860, 5, 409, 0, 0, 2857, 2858, 5, 76, 0, + 0, 2858, 2860, 5, 314, 0, 0, 2859, 2845, 1, 0, 0, 0, 2859, 2847, 1, 0, + 0, 0, 2859, 2849, 1, 0, 0, 0, 2859, 2855, 1, 0, 0, 0, 2859, 2857, 1, 0, + 0, 0, 2860, 281, 1, 0, 0, 0, 2861, 2862, 5, 502, 0, 0, 2862, 2863, 5, 472, + 0, 0, 2863, 2864, 3, 284, 142, 0, 2864, 283, 1, 0, 0, 0, 2865, 2866, 5, + 119, 0, 0, 2866, 2867, 5, 485, 0, 0, 2867, 2868, 5, 502, 0, 0, 2868, 2925, + 5, 486, 0, 0, 2869, 2870, 5, 120, 0, 0, 2870, 2871, 5, 485, 0, 0, 2871, + 2872, 5, 502, 0, 0, 2872, 2925, 5, 486, 0, 0, 2873, 2874, 5, 121, 0, 0, + 2874, 2875, 5, 485, 0, 0, 2875, 2876, 5, 502, 0, 0, 2876, 2877, 5, 483, + 0, 0, 2877, 2878, 3, 646, 323, 0, 2878, 2879, 5, 486, 0, 0, 2879, 2925, + 1, 0, 0, 0, 2880, 2881, 5, 183, 0, 0, 2881, 2882, 5, 485, 0, 0, 2882, 2883, + 5, 502, 0, 0, 2883, 2884, 5, 483, 0, 0, 2884, 2885, 3, 646, 323, 0, 2885, + 2886, 5, 486, 0, 0, 2886, 2925, 1, 0, 0, 0, 2887, 2888, 5, 122, 0, 0, 2888, + 2889, 5, 485, 0, 0, 2889, 2890, 5, 502, 0, 0, 2890, 2891, 5, 483, 0, 0, + 2891, 2892, 3, 286, 143, 0, 2892, 2893, 5, 486, 0, 0, 2893, 2925, 1, 0, + 0, 0, 2894, 2895, 5, 123, 0, 0, 2895, 2896, 5, 485, 0, 0, 2896, 2897, 5, + 502, 0, 0, 2897, 2898, 5, 483, 0, 0, 2898, 2899, 5, 502, 0, 0, 2899, 2925, + 5, 486, 0, 0, 2900, 2901, 5, 124, 0, 0, 2901, 2902, 5, 485, 0, 0, 2902, + 2903, 5, 502, 0, 0, 2903, 2904, 5, 483, 0, 0, 2904, 2905, 5, 502, 0, 0, + 2905, 2925, 5, 486, 0, 0, 2906, 2907, 5, 125, 0, 0, 2907, 2908, 5, 485, + 0, 0, 2908, 2909, 5, 502, 0, 0, 2909, 2910, 5, 483, 0, 0, 2910, 2911, 5, + 502, 0, 0, 2911, 2925, 5, 486, 0, 0, 2912, 2913, 5, 126, 0, 0, 2913, 2914, + 5, 485, 0, 0, 2914, 2915, 5, 502, 0, 0, 2915, 2916, 5, 483, 0, 0, 2916, + 2917, 5, 502, 0, 0, 2917, 2925, 5, 486, 0, 0, 2918, 2919, 5, 132, 0, 0, + 2919, 2920, 5, 485, 0, 0, 2920, 2921, 5, 502, 0, 0, 2921, 2922, 5, 483, + 0, 0, 2922, 2923, 5, 502, 0, 0, 2923, 2925, 5, 486, 0, 0, 2924, 2865, 1, + 0, 0, 0, 2924, 2869, 1, 0, 0, 0, 2924, 2873, 1, 0, 0, 0, 2924, 2880, 1, + 0, 0, 0, 2924, 2887, 1, 0, 0, 0, 2924, 2894, 1, 0, 0, 0, 2924, 2900, 1, + 0, 0, 0, 2924, 2906, 1, 0, 0, 0, 2924, 2912, 1, 0, 0, 0, 2924, 2918, 1, + 0, 0, 0, 2925, 285, 1, 0, 0, 0, 2926, 2931, 3, 288, 144, 0, 2927, 2928, + 5, 483, 0, 0, 2928, 2930, 3, 288, 144, 0, 2929, 2927, 1, 0, 0, 0, 2930, + 2933, 1, 0, 0, 0, 2931, 2929, 1, 0, 0, 0, 2931, 2932, 1, 0, 0, 0, 2932, + 287, 1, 0, 0, 0, 2933, 2931, 1, 0, 0, 0, 2934, 2936, 5, 503, 0, 0, 2935, + 2937, 7, 6, 0, 0, 2936, 2935, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, + 289, 1, 0, 0, 0, 2938, 2939, 5, 502, 0, 0, 2939, 2940, 5, 472, 0, 0, 2940, + 2941, 3, 292, 146, 0, 2941, 291, 1, 0, 0, 0, 2942, 2943, 5, 271, 0, 0, + 2943, 2944, 5, 485, 0, 0, 2944, 2945, 5, 502, 0, 0, 2945, 2967, 5, 486, + 0, 0, 2946, 2947, 5, 272, 0, 0, 2947, 2948, 5, 485, 0, 0, 2948, 2949, 3, + 196, 98, 0, 2949, 2950, 5, 486, 0, 0, 2950, 2967, 1, 0, 0, 0, 2951, 2952, + 5, 127, 0, 0, 2952, 2953, 5, 485, 0, 0, 2953, 2954, 3, 196, 98, 0, 2954, + 2955, 5, 486, 0, 0, 2955, 2967, 1, 0, 0, 0, 2956, 2957, 5, 128, 0, 0, 2957, + 2958, 5, 485, 0, 0, 2958, 2959, 3, 196, 98, 0, 2959, 2960, 5, 486, 0, 0, + 2960, 2967, 1, 0, 0, 0, 2961, 2962, 5, 129, 0, 0, 2962, 2963, 5, 485, 0, + 0, 2963, 2964, 3, 196, 98, 0, 2964, 2965, 5, 486, 0, 0, 2965, 2967, 1, + 0, 0, 0, 2966, 2942, 1, 0, 0, 0, 2966, 2946, 1, 0, 0, 0, 2966, 2951, 1, + 0, 0, 0, 2966, 2956, 1, 0, 0, 0, 2966, 2961, 1, 0, 0, 0, 2967, 293, 1, + 0, 0, 0, 2968, 2969, 5, 502, 0, 0, 2969, 2970, 5, 472, 0, 0, 2970, 2971, + 5, 17, 0, 0, 2971, 2972, 5, 13, 0, 0, 2972, 2973, 3, 684, 342, 0, 2973, + 295, 1, 0, 0, 0, 2974, 2975, 5, 46, 0, 0, 2975, 2976, 5, 502, 0, 0, 2976, + 2977, 5, 411, 0, 0, 2977, 2978, 5, 502, 0, 0, 2978, 297, 1, 0, 0, 0, 2979, + 2980, 5, 131, 0, 0, 2980, 2981, 5, 502, 0, 0, 2981, 2982, 5, 70, 0, 0, + 2982, 2983, 5, 502, 0, 0, 2983, 299, 1, 0, 0, 0, 2984, 2989, 3, 302, 151, + 0, 2985, 2986, 5, 483, 0, 0, 2986, 2988, 3, 302, 151, 0, 2987, 2985, 1, + 0, 0, 0, 2988, 2991, 1, 0, 0, 0, 2989, 2987, 1, 0, 0, 0, 2989, 2990, 1, + 0, 0, 0, 2990, 301, 1, 0, 0, 0, 2991, 2989, 1, 0, 0, 0, 2992, 2993, 3, + 304, 152, 0, 2993, 2994, 5, 472, 0, 0, 2994, 2995, 3, 646, 323, 0, 2995, + 303, 1, 0, 0, 0, 2996, 3001, 3, 684, 342, 0, 2997, 3001, 5, 503, 0, 0, + 2998, 3001, 5, 505, 0, 0, 2999, 3001, 3, 706, 353, 0, 3000, 2996, 1, 0, + 0, 0, 3000, 2997, 1, 0, 0, 0, 3000, 2998, 1, 0, 0, 0, 3000, 2999, 1, 0, + 0, 0, 3001, 305, 1, 0, 0, 0, 3002, 3007, 3, 308, 154, 0, 3003, 3004, 5, + 483, 0, 0, 3004, 3006, 3, 308, 154, 0, 3005, 3003, 1, 0, 0, 0, 3006, 3009, + 1, 0, 0, 0, 3007, 3005, 1, 0, 0, 0, 3007, 3008, 1, 0, 0, 0, 3008, 307, + 1, 0, 0, 0, 3009, 3007, 1, 0, 0, 0, 3010, 3011, 5, 503, 0, 0, 3011, 3012, + 5, 472, 0, 0, 3012, 3013, 3, 646, 323, 0, 3013, 309, 1, 0, 0, 0, 3014, + 3015, 5, 33, 0, 0, 3015, 3016, 3, 684, 342, 0, 3016, 3017, 3, 360, 180, + 0, 3017, 3018, 5, 487, 0, 0, 3018, 3019, 3, 368, 184, 0, 3019, 3020, 5, + 488, 0, 0, 3020, 311, 1, 0, 0, 0, 3021, 3022, 5, 34, 0, 0, 3022, 3024, + 3, 684, 342, 0, 3023, 3025, 3, 364, 182, 0, 3024, 3023, 1, 0, 0, 0, 3024, + 3025, 1, 0, 0, 0, 3025, 3027, 1, 0, 0, 0, 3026, 3028, 3, 314, 157, 0, 3027, + 3026, 1, 0, 0, 0, 3027, 3028, 1, 0, 0, 0, 3028, 3029, 1, 0, 0, 0, 3029, + 3030, 5, 487, 0, 0, 3030, 3031, 3, 368, 184, 0, 3031, 3032, 5, 488, 0, + 0, 3032, 313, 1, 0, 0, 0, 3033, 3035, 3, 316, 158, 0, 3034, 3033, 1, 0, + 0, 0, 3035, 3036, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, + 0, 0, 3037, 315, 1, 0, 0, 0, 3038, 3039, 5, 215, 0, 0, 3039, 3040, 5, 499, + 0, 0, 3040, 317, 1, 0, 0, 0, 3041, 3046, 3, 320, 160, 0, 3042, 3043, 5, + 483, 0, 0, 3043, 3045, 3, 320, 160, 0, 3044, 3042, 1, 0, 0, 0, 3045, 3048, + 1, 0, 0, 0, 3046, 3044, 1, 0, 0, 0, 3046, 3047, 1, 0, 0, 0, 3047, 319, + 1, 0, 0, 0, 3048, 3046, 1, 0, 0, 0, 3049, 3050, 7, 15, 0, 0, 3050, 3051, + 5, 491, 0, 0, 3051, 3052, 3, 102, 51, 0, 3052, 321, 1, 0, 0, 0, 3053, 3058, + 3, 324, 162, 0, 3054, 3055, 5, 483, 0, 0, 3055, 3057, 3, 324, 162, 0, 3056, + 3054, 1, 0, 0, 0, 3057, 3060, 1, 0, 0, 0, 3058, 3056, 1, 0, 0, 0, 3058, + 3059, 1, 0, 0, 0, 3059, 323, 1, 0, 0, 0, 3060, 3058, 1, 0, 0, 0, 3061, + 3062, 7, 15, 0, 0, 3062, 3063, 5, 491, 0, 0, 3063, 3064, 3, 102, 51, 0, + 3064, 325, 1, 0, 0, 0, 3065, 3070, 3, 328, 164, 0, 3066, 3067, 5, 483, + 0, 0, 3067, 3069, 3, 328, 164, 0, 3068, 3066, 1, 0, 0, 0, 3069, 3072, 1, + 0, 0, 0, 3070, 3068, 1, 0, 0, 0, 3070, 3071, 1, 0, 0, 0, 3071, 327, 1, + 0, 0, 0, 3072, 3070, 1, 0, 0, 0, 3073, 3074, 5, 502, 0, 0, 3074, 3075, + 5, 491, 0, 0, 3075, 3076, 3, 102, 51, 0, 3076, 3077, 5, 472, 0, 0, 3077, + 3078, 5, 499, 0, 0, 3078, 329, 1, 0, 0, 0, 3079, 3082, 3, 684, 342, 0, + 3080, 3082, 5, 503, 0, 0, 3081, 3079, 1, 0, 0, 0, 3081, 3080, 1, 0, 0, + 0, 3082, 3084, 1, 0, 0, 0, 3083, 3085, 7, 6, 0, 0, 3084, 3083, 1, 0, 0, + 0, 3084, 3085, 1, 0, 0, 0, 3085, 331, 1, 0, 0, 0, 3086, 3087, 5, 489, 0, + 0, 3087, 3088, 3, 336, 168, 0, 3088, 3089, 5, 490, 0, 0, 3089, 333, 1, + 0, 0, 0, 3090, 3091, 7, 16, 0, 0, 3091, 335, 1, 0, 0, 0, 3092, 3097, 3, + 338, 169, 0, 3093, 3094, 5, 281, 0, 0, 3094, 3096, 3, 338, 169, 0, 3095, + 3093, 1, 0, 0, 0, 3096, 3099, 1, 0, 0, 0, 3097, 3095, 1, 0, 0, 0, 3097, + 3098, 1, 0, 0, 0, 3098, 337, 1, 0, 0, 0, 3099, 3097, 1, 0, 0, 0, 3100, + 3105, 3, 340, 170, 0, 3101, 3102, 5, 280, 0, 0, 3102, 3104, 3, 340, 170, + 0, 3103, 3101, 1, 0, 0, 0, 3104, 3107, 1, 0, 0, 0, 3105, 3103, 1, 0, 0, + 0, 3105, 3106, 1, 0, 0, 0, 3106, 339, 1, 0, 0, 0, 3107, 3105, 1, 0, 0, + 0, 3108, 3109, 5, 282, 0, 0, 3109, 3112, 3, 340, 170, 0, 3110, 3112, 3, + 342, 171, 0, 3111, 3108, 1, 0, 0, 0, 3111, 3110, 1, 0, 0, 0, 3112, 341, + 1, 0, 0, 0, 3113, 3117, 3, 344, 172, 0, 3114, 3115, 3, 656, 328, 0, 3115, + 3116, 3, 344, 172, 0, 3116, 3118, 1, 0, 0, 0, 3117, 3114, 1, 0, 0, 0, 3117, + 3118, 1, 0, 0, 0, 3118, 343, 1, 0, 0, 0, 3119, 3126, 3, 356, 178, 0, 3120, + 3126, 3, 346, 173, 0, 3121, 3122, 5, 485, 0, 0, 3122, 3123, 3, 336, 168, + 0, 3123, 3124, 5, 486, 0, 0, 3124, 3126, 1, 0, 0, 0, 3125, 3119, 1, 0, + 0, 0, 3125, 3120, 1, 0, 0, 0, 3125, 3121, 1, 0, 0, 0, 3126, 345, 1, 0, + 0, 0, 3127, 3132, 3, 348, 174, 0, 3128, 3129, 5, 478, 0, 0, 3129, 3131, + 3, 348, 174, 0, 3130, 3128, 1, 0, 0, 0, 3131, 3134, 1, 0, 0, 0, 3132, 3130, + 1, 0, 0, 0, 3132, 3133, 1, 0, 0, 0, 3133, 347, 1, 0, 0, 0, 3134, 3132, + 1, 0, 0, 0, 3135, 3140, 3, 350, 175, 0, 3136, 3137, 5, 489, 0, 0, 3137, + 3138, 3, 336, 168, 0, 3138, 3139, 5, 490, 0, 0, 3139, 3141, 1, 0, 0, 0, + 3140, 3136, 1, 0, 0, 0, 3140, 3141, 1, 0, 0, 0, 3141, 349, 1, 0, 0, 0, + 3142, 3148, 3, 352, 176, 0, 3143, 3148, 5, 502, 0, 0, 3144, 3148, 5, 499, + 0, 0, 3145, 3148, 5, 501, 0, 0, 3146, 3148, 5, 498, 0, 0, 3147, 3142, 1, + 0, 0, 0, 3147, 3143, 1, 0, 0, 0, 3147, 3144, 1, 0, 0, 0, 3147, 3145, 1, + 0, 0, 0, 3147, 3146, 1, 0, 0, 0, 3148, 351, 1, 0, 0, 0, 3149, 3154, 3, + 354, 177, 0, 3150, 3151, 5, 484, 0, 0, 3151, 3153, 3, 354, 177, 0, 3152, + 3150, 1, 0, 0, 0, 3153, 3156, 1, 0, 0, 0, 3154, 3152, 1, 0, 0, 0, 3154, + 3155, 1, 0, 0, 0, 3155, 353, 1, 0, 0, 0, 3156, 3154, 1, 0, 0, 0, 3157, + 3158, 8, 17, 0, 0, 3158, 355, 1, 0, 0, 0, 3159, 3160, 3, 358, 179, 0, 3160, + 3169, 5, 485, 0, 0, 3161, 3166, 3, 336, 168, 0, 3162, 3163, 5, 483, 0, + 0, 3163, 3165, 3, 336, 168, 0, 3164, 3162, 1, 0, 0, 0, 3165, 3168, 1, 0, + 0, 0, 3166, 3164, 1, 0, 0, 0, 3166, 3167, 1, 0, 0, 0, 3167, 3170, 1, 0, + 0, 0, 3168, 3166, 1, 0, 0, 0, 3169, 3161, 1, 0, 0, 0, 3169, 3170, 1, 0, + 0, 0, 3170, 3171, 1, 0, 0, 0, 3171, 3172, 5, 486, 0, 0, 3172, 357, 1, 0, + 0, 0, 3173, 3174, 7, 18, 0, 0, 3174, 359, 1, 0, 0, 0, 3175, 3176, 5, 485, + 0, 0, 3176, 3181, 3, 362, 181, 0, 3177, 3178, 5, 483, 0, 0, 3178, 3180, + 3, 362, 181, 0, 3179, 3177, 1, 0, 0, 0, 3180, 3183, 1, 0, 0, 0, 3181, 3179, + 1, 0, 0, 0, 3181, 3182, 1, 0, 0, 0, 3182, 3184, 1, 0, 0, 0, 3183, 3181, + 1, 0, 0, 0, 3184, 3185, 5, 486, 0, 0, 3185, 361, 1, 0, 0, 0, 3186, 3187, + 5, 200, 0, 0, 3187, 3188, 5, 491, 0, 0, 3188, 3189, 5, 487, 0, 0, 3189, + 3190, 3, 318, 159, 0, 3190, 3191, 5, 488, 0, 0, 3191, 3214, 1, 0, 0, 0, + 3192, 3193, 5, 201, 0, 0, 3193, 3194, 5, 491, 0, 0, 3194, 3195, 5, 487, + 0, 0, 3195, 3196, 3, 326, 163, 0, 3196, 3197, 5, 488, 0, 0, 3197, 3214, + 1, 0, 0, 0, 3198, 3199, 5, 162, 0, 0, 3199, 3200, 5, 491, 0, 0, 3200, 3214, + 5, 499, 0, 0, 3201, 3202, 5, 35, 0, 0, 3202, 3205, 5, 491, 0, 0, 3203, + 3206, 3, 684, 342, 0, 3204, 3206, 5, 499, 0, 0, 3205, 3203, 1, 0, 0, 0, + 3205, 3204, 1, 0, 0, 0, 3206, 3214, 1, 0, 0, 0, 3207, 3208, 5, 214, 0, + 0, 3208, 3209, 5, 491, 0, 0, 3209, 3214, 5, 499, 0, 0, 3210, 3211, 5, 215, + 0, 0, 3211, 3212, 5, 491, 0, 0, 3212, 3214, 5, 499, 0, 0, 3213, 3186, 1, + 0, 0, 0, 3213, 3192, 1, 0, 0, 0, 3213, 3198, 1, 0, 0, 0, 3213, 3201, 1, + 0, 0, 0, 3213, 3207, 1, 0, 0, 0, 3213, 3210, 1, 0, 0, 0, 3214, 363, 1, + 0, 0, 0, 3215, 3216, 5, 485, 0, 0, 3216, 3221, 3, 366, 183, 0, 3217, 3218, + 5, 483, 0, 0, 3218, 3220, 3, 366, 183, 0, 3219, 3217, 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, 3225, 5, 486, 0, 0, 3225, + 365, 1, 0, 0, 0, 3226, 3227, 5, 200, 0, 0, 3227, 3228, 5, 491, 0, 0, 3228, + 3229, 5, 487, 0, 0, 3229, 3230, 3, 322, 161, 0, 3230, 3231, 5, 488, 0, + 0, 3231, 3242, 1, 0, 0, 0, 3232, 3233, 5, 201, 0, 0, 3233, 3234, 5, 491, + 0, 0, 3234, 3235, 5, 487, 0, 0, 3235, 3236, 3, 326, 163, 0, 3236, 3237, + 5, 488, 0, 0, 3237, 3242, 1, 0, 0, 0, 3238, 3239, 5, 215, 0, 0, 3239, 3240, + 5, 491, 0, 0, 3240, 3242, 5, 499, 0, 0, 3241, 3226, 1, 0, 0, 0, 3241, 3232, + 1, 0, 0, 0, 3241, 3238, 1, 0, 0, 0, 3242, 367, 1, 0, 0, 0, 3243, 3246, + 3, 372, 186, 0, 3244, 3246, 3, 370, 185, 0, 3245, 3243, 1, 0, 0, 0, 3245, + 3244, 1, 0, 0, 0, 3246, 3249, 1, 0, 0, 0, 3247, 3245, 1, 0, 0, 0, 3247, + 3248, 1, 0, 0, 0, 3248, 369, 1, 0, 0, 0, 3249, 3247, 1, 0, 0, 0, 3250, + 3251, 5, 66, 0, 0, 3251, 3252, 5, 378, 0, 0, 3252, 3255, 3, 686, 343, 0, + 3253, 3254, 5, 75, 0, 0, 3254, 3256, 3, 686, 343, 0, 3255, 3253, 1, 0, + 0, 0, 3255, 3256, 1, 0, 0, 0, 3256, 371, 1, 0, 0, 0, 3257, 3258, 3, 374, + 187, 0, 3258, 3260, 5, 503, 0, 0, 3259, 3261, 3, 376, 188, 0, 3260, 3259, + 1, 0, 0, 0, 3260, 3261, 1, 0, 0, 0, 3261, 3263, 1, 0, 0, 0, 3262, 3264, + 3, 414, 207, 0, 3263, 3262, 1, 0, 0, 0, 3263, 3264, 1, 0, 0, 0, 3264, 373, + 1, 0, 0, 0, 3265, 3266, 7, 19, 0, 0, 3266, 375, 1, 0, 0, 0, 3267, 3268, + 5, 485, 0, 0, 3268, 3273, 3, 378, 189, 0, 3269, 3270, 5, 483, 0, 0, 3270, + 3272, 3, 378, 189, 0, 3271, 3269, 1, 0, 0, 0, 3272, 3275, 1, 0, 0, 0, 3273, + 3271, 1, 0, 0, 0, 3273, 3274, 1, 0, 0, 0, 3274, 3276, 1, 0, 0, 0, 3275, + 3273, 1, 0, 0, 0, 3276, 3277, 5, 486, 0, 0, 3277, 377, 1, 0, 0, 0, 3278, + 3279, 5, 189, 0, 0, 3279, 3280, 5, 491, 0, 0, 3280, 3354, 3, 384, 192, + 0, 3281, 3282, 5, 38, 0, 0, 3282, 3283, 5, 491, 0, 0, 3283, 3354, 3, 392, + 196, 0, 3284, 3285, 5, 196, 0, 0, 3285, 3286, 5, 491, 0, 0, 3286, 3354, + 3, 392, 196, 0, 3287, 3288, 5, 114, 0, 0, 3288, 3289, 5, 491, 0, 0, 3289, + 3354, 3, 386, 193, 0, 3290, 3291, 5, 186, 0, 0, 3291, 3292, 5, 491, 0, + 0, 3292, 3354, 3, 394, 197, 0, 3293, 3294, 5, 166, 0, 0, 3294, 3295, 5, + 491, 0, 0, 3295, 3354, 5, 499, 0, 0, 3296, 3297, 5, 197, 0, 0, 3297, 3298, + 5, 491, 0, 0, 3298, 3354, 3, 392, 196, 0, 3299, 3300, 5, 194, 0, 0, 3300, + 3301, 5, 491, 0, 0, 3301, 3354, 3, 394, 197, 0, 3302, 3303, 5, 195, 0, + 0, 3303, 3304, 5, 491, 0, 0, 3304, 3354, 3, 400, 200, 0, 3305, 3306, 5, + 198, 0, 0, 3306, 3307, 5, 491, 0, 0, 3307, 3354, 3, 396, 198, 0, 3308, + 3309, 5, 199, 0, 0, 3309, 3310, 5, 491, 0, 0, 3310, 3354, 3, 396, 198, + 0, 3311, 3312, 5, 205, 0, 0, 3312, 3313, 5, 491, 0, 0, 3313, 3354, 3, 402, + 201, 0, 3314, 3315, 5, 203, 0, 0, 3315, 3316, 5, 491, 0, 0, 3316, 3354, + 5, 499, 0, 0, 3317, 3318, 5, 204, 0, 0, 3318, 3319, 5, 491, 0, 0, 3319, + 3354, 5, 499, 0, 0, 3320, 3321, 5, 202, 0, 0, 3321, 3322, 5, 491, 0, 0, + 3322, 3354, 3, 404, 202, 0, 3323, 3324, 5, 191, 0, 0, 3324, 3325, 5, 491, + 0, 0, 3325, 3354, 3, 406, 203, 0, 3326, 3327, 5, 34, 0, 0, 3327, 3328, + 5, 491, 0, 0, 3328, 3354, 3, 684, 342, 0, 3329, 3330, 5, 220, 0, 0, 3330, + 3331, 5, 491, 0, 0, 3331, 3354, 3, 382, 191, 0, 3332, 3333, 5, 221, 0, + 0, 3333, 3334, 5, 491, 0, 0, 3334, 3354, 3, 380, 190, 0, 3335, 3336, 5, + 208, 0, 0, 3336, 3337, 5, 491, 0, 0, 3337, 3354, 3, 410, 205, 0, 3338, + 3339, 5, 211, 0, 0, 3339, 3340, 5, 491, 0, 0, 3340, 3354, 5, 501, 0, 0, + 3341, 3342, 5, 212, 0, 0, 3342, 3343, 5, 491, 0, 0, 3343, 3354, 5, 501, + 0, 0, 3344, 3345, 5, 227, 0, 0, 3345, 3346, 5, 491, 0, 0, 3346, 3354, 3, + 408, 204, 0, 3347, 3348, 5, 188, 0, 0, 3348, 3349, 5, 491, 0, 0, 3349, + 3354, 3, 408, 204, 0, 3350, 3351, 5, 503, 0, 0, 3351, 3352, 5, 491, 0, + 0, 3352, 3354, 3, 408, 204, 0, 3353, 3278, 1, 0, 0, 0, 3353, 3281, 1, 0, + 0, 0, 3353, 3284, 1, 0, 0, 0, 3353, 3287, 1, 0, 0, 0, 3353, 3290, 1, 0, + 0, 0, 3353, 3293, 1, 0, 0, 0, 3353, 3296, 1, 0, 0, 0, 3353, 3299, 1, 0, + 0, 0, 3353, 3302, 1, 0, 0, 0, 3353, 3305, 1, 0, 0, 0, 3353, 3308, 1, 0, + 0, 0, 3353, 3311, 1, 0, 0, 0, 3353, 3314, 1, 0, 0, 0, 3353, 3317, 1, 0, + 0, 0, 3353, 3320, 1, 0, 0, 0, 3353, 3323, 1, 0, 0, 0, 3353, 3326, 1, 0, + 0, 0, 3353, 3329, 1, 0, 0, 0, 3353, 3332, 1, 0, 0, 0, 3353, 3335, 1, 0, + 0, 0, 3353, 3338, 1, 0, 0, 0, 3353, 3341, 1, 0, 0, 0, 3353, 3344, 1, 0, + 0, 0, 3353, 3347, 1, 0, 0, 0, 3353, 3350, 1, 0, 0, 0, 3354, 379, 1, 0, + 0, 0, 3355, 3356, 7, 20, 0, 0, 3356, 381, 1, 0, 0, 0, 3357, 3358, 5, 489, + 0, 0, 3358, 3363, 3, 684, 342, 0, 3359, 3360, 5, 483, 0, 0, 3360, 3362, + 3, 684, 342, 0, 3361, 3359, 1, 0, 0, 0, 3362, 3365, 1, 0, 0, 0, 3363, 3361, + 1, 0, 0, 0, 3363, 3364, 1, 0, 0, 0, 3364, 3366, 1, 0, 0, 0, 3365, 3363, + 1, 0, 0, 0, 3366, 3367, 5, 490, 0, 0, 3367, 383, 1, 0, 0, 0, 3368, 3415, + 5, 502, 0, 0, 3369, 3371, 5, 344, 0, 0, 3370, 3372, 5, 70, 0, 0, 3371, + 3370, 1, 0, 0, 0, 3371, 3372, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, + 3387, 3, 684, 342, 0, 3374, 3385, 5, 71, 0, 0, 3375, 3381, 3, 332, 166, + 0, 3376, 3377, 3, 334, 167, 0, 3377, 3378, 3, 332, 166, 0, 3378, 3380, + 1, 0, 0, 0, 3379, 3376, 1, 0, 0, 0, 3380, 3383, 1, 0, 0, 0, 3381, 3379, + 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, 3386, 1, 0, 0, 0, 3383, 3381, + 1, 0, 0, 0, 3384, 3386, 3, 646, 323, 0, 3385, 3375, 1, 0, 0, 0, 3385, 3384, + 1, 0, 0, 0, 3386, 3388, 1, 0, 0, 0, 3387, 3374, 1, 0, 0, 0, 3387, 3388, + 1, 0, 0, 0, 3388, 3398, 1, 0, 0, 0, 3389, 3390, 5, 10, 0, 0, 3390, 3395, + 3, 330, 165, 0, 3391, 3392, 5, 483, 0, 0, 3392, 3394, 3, 330, 165, 0, 3393, + 3391, 1, 0, 0, 0, 3394, 3397, 1, 0, 0, 0, 3395, 3393, 1, 0, 0, 0, 3395, + 3396, 1, 0, 0, 0, 3396, 3399, 1, 0, 0, 0, 3397, 3395, 1, 0, 0, 0, 3398, + 3389, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0, 3399, 3415, 1, 0, 0, 0, 3400, + 3401, 5, 30, 0, 0, 3401, 3403, 3, 684, 342, 0, 3402, 3404, 3, 388, 194, + 0, 3403, 3402, 1, 0, 0, 0, 3403, 3404, 1, 0, 0, 0, 3404, 3415, 1, 0, 0, + 0, 3405, 3406, 5, 31, 0, 0, 3406, 3408, 3, 684, 342, 0, 3407, 3409, 3, + 388, 194, 0, 3408, 3407, 1, 0, 0, 0, 3408, 3409, 1, 0, 0, 0, 3409, 3415, + 1, 0, 0, 0, 3410, 3411, 5, 27, 0, 0, 3411, 3415, 3, 392, 196, 0, 3412, + 3413, 5, 191, 0, 0, 3413, 3415, 5, 503, 0, 0, 3414, 3368, 1, 0, 0, 0, 3414, + 3369, 1, 0, 0, 0, 3414, 3400, 1, 0, 0, 0, 3414, 3405, 1, 0, 0, 0, 3414, + 3410, 1, 0, 0, 0, 3414, 3412, 1, 0, 0, 0, 3415, 385, 1, 0, 0, 0, 3416, + 3418, 5, 229, 0, 0, 3417, 3419, 5, 231, 0, 0, 3418, 3417, 1, 0, 0, 0, 3418, + 3419, 1, 0, 0, 0, 3419, 3455, 1, 0, 0, 0, 3420, 3422, 5, 230, 0, 0, 3421, + 3423, 5, 231, 0, 0, 3422, 3421, 1, 0, 0, 0, 3422, 3423, 1, 0, 0, 0, 3423, + 3455, 1, 0, 0, 0, 3424, 3455, 5, 231, 0, 0, 3425, 3455, 5, 234, 0, 0, 3426, + 3428, 5, 99, 0, 0, 3427, 3429, 5, 231, 0, 0, 3428, 3427, 1, 0, 0, 0, 3428, + 3429, 1, 0, 0, 0, 3429, 3455, 1, 0, 0, 0, 3430, 3431, 5, 235, 0, 0, 3431, + 3434, 3, 684, 342, 0, 3432, 3433, 5, 80, 0, 0, 3433, 3435, 3, 386, 193, + 0, 3434, 3432, 1, 0, 0, 0, 3434, 3435, 1, 0, 0, 0, 3435, 3455, 1, 0, 0, + 0, 3436, 3437, 5, 232, 0, 0, 3437, 3439, 3, 684, 342, 0, 3438, 3440, 3, + 388, 194, 0, 3439, 3438, 1, 0, 0, 0, 3439, 3440, 1, 0, 0, 0, 3440, 3455, + 1, 0, 0, 0, 3441, 3442, 5, 30, 0, 0, 3442, 3444, 3, 684, 342, 0, 3443, + 3445, 3, 388, 194, 0, 3444, 3443, 1, 0, 0, 0, 3444, 3445, 1, 0, 0, 0, 3445, + 3455, 1, 0, 0, 0, 3446, 3447, 5, 31, 0, 0, 3447, 3449, 3, 684, 342, 0, + 3448, 3450, 3, 388, 194, 0, 3449, 3448, 1, 0, 0, 0, 3449, 3450, 1, 0, 0, + 0, 3450, 3455, 1, 0, 0, 0, 3451, 3452, 5, 238, 0, 0, 3452, 3455, 5, 499, + 0, 0, 3453, 3455, 5, 239, 0, 0, 3454, 3416, 1, 0, 0, 0, 3454, 3420, 1, + 0, 0, 0, 3454, 3424, 1, 0, 0, 0, 3454, 3425, 1, 0, 0, 0, 3454, 3426, 1, + 0, 0, 0, 3454, 3430, 1, 0, 0, 0, 3454, 3436, 1, 0, 0, 0, 3454, 3441, 1, + 0, 0, 0, 3454, 3446, 1, 0, 0, 0, 3454, 3451, 1, 0, 0, 0, 3454, 3453, 1, + 0, 0, 0, 3455, 387, 1, 0, 0, 0, 3456, 3457, 5, 485, 0, 0, 3457, 3462, 3, + 390, 195, 0, 3458, 3459, 5, 483, 0, 0, 3459, 3461, 3, 390, 195, 0, 3460, + 3458, 1, 0, 0, 0, 3461, 3464, 1, 0, 0, 0, 3462, 3460, 1, 0, 0, 0, 3462, + 3463, 1, 0, 0, 0, 3463, 3465, 1, 0, 0, 0, 3464, 3462, 1, 0, 0, 0, 3465, + 3466, 5, 486, 0, 0, 3466, 389, 1, 0, 0, 0, 3467, 3468, 5, 503, 0, 0, 3468, + 3469, 5, 491, 0, 0, 3469, 3474, 3, 646, 323, 0, 3470, 3471, 5, 502, 0, + 0, 3471, 3472, 5, 472, 0, 0, 3472, 3474, 3, 646, 323, 0, 3473, 3467, 1, + 0, 0, 0, 3473, 3470, 1, 0, 0, 0, 3474, 391, 1, 0, 0, 0, 3475, 3479, 5, + 503, 0, 0, 3476, 3479, 5, 505, 0, 0, 3477, 3479, 3, 708, 354, 0, 3478, + 3475, 1, 0, 0, 0, 3478, 3476, 1, 0, 0, 0, 3478, 3477, 1, 0, 0, 0, 3479, + 3488, 1, 0, 0, 0, 3480, 3484, 5, 478, 0, 0, 3481, 3485, 5, 503, 0, 0, 3482, + 3485, 5, 505, 0, 0, 3483, 3485, 3, 708, 354, 0, 3484, 3481, 1, 0, 0, 0, + 3484, 3482, 1, 0, 0, 0, 3484, 3483, 1, 0, 0, 0, 3485, 3487, 1, 0, 0, 0, + 3486, 3480, 1, 0, 0, 0, 3487, 3490, 1, 0, 0, 0, 3488, 3486, 1, 0, 0, 0, + 3488, 3489, 1, 0, 0, 0, 3489, 393, 1, 0, 0, 0, 3490, 3488, 1, 0, 0, 0, + 3491, 3502, 5, 499, 0, 0, 3492, 3502, 3, 392, 196, 0, 3493, 3499, 5, 502, + 0, 0, 3494, 3497, 5, 484, 0, 0, 3495, 3498, 5, 503, 0, 0, 3496, 3498, 3, + 708, 354, 0, 3497, 3495, 1, 0, 0, 0, 3497, 3496, 1, 0, 0, 0, 3498, 3500, + 1, 0, 0, 0, 3499, 3494, 1, 0, 0, 0, 3499, 3500, 1, 0, 0, 0, 3500, 3502, + 1, 0, 0, 0, 3501, 3491, 1, 0, 0, 0, 3501, 3492, 1, 0, 0, 0, 3501, 3493, + 1, 0, 0, 0, 3502, 395, 1, 0, 0, 0, 3503, 3504, 5, 489, 0, 0, 3504, 3509, + 3, 398, 199, 0, 3505, 3506, 5, 483, 0, 0, 3506, 3508, 3, 398, 199, 0, 3507, + 3505, 1, 0, 0, 0, 3508, 3511, 1, 0, 0, 0, 3509, 3507, 1, 0, 0, 0, 3509, + 3510, 1, 0, 0, 0, 3510, 3512, 1, 0, 0, 0, 3511, 3509, 1, 0, 0, 0, 3512, + 3513, 5, 490, 0, 0, 3513, 397, 1, 0, 0, 0, 3514, 3515, 5, 487, 0, 0, 3515, + 3516, 5, 501, 0, 0, 3516, 3517, 5, 488, 0, 0, 3517, 3518, 5, 472, 0, 0, + 3518, 3519, 3, 646, 323, 0, 3519, 399, 1, 0, 0, 0, 3520, 3521, 7, 21, 0, + 0, 3521, 401, 1, 0, 0, 0, 3522, 3523, 7, 22, 0, 0, 3523, 403, 1, 0, 0, + 0, 3524, 3525, 7, 23, 0, 0, 3525, 405, 1, 0, 0, 0, 3526, 3527, 7, 24, 0, + 0, 3527, 407, 1, 0, 0, 0, 3528, 3552, 5, 499, 0, 0, 3529, 3552, 5, 501, + 0, 0, 3530, 3552, 3, 692, 346, 0, 3531, 3552, 3, 684, 342, 0, 3532, 3552, + 5, 503, 0, 0, 3533, 3552, 5, 250, 0, 0, 3534, 3552, 5, 251, 0, 0, 3535, + 3552, 5, 252, 0, 0, 3536, 3552, 5, 253, 0, 0, 3537, 3552, 5, 254, 0, 0, + 3538, 3552, 5, 255, 0, 0, 3539, 3548, 5, 489, 0, 0, 3540, 3545, 3, 646, + 323, 0, 3541, 3542, 5, 483, 0, 0, 3542, 3544, 3, 646, 323, 0, 3543, 3541, + 1, 0, 0, 0, 3544, 3547, 1, 0, 0, 0, 3545, 3543, 1, 0, 0, 0, 3545, 3546, + 1, 0, 0, 0, 3546, 3549, 1, 0, 0, 0, 3547, 3545, 1, 0, 0, 0, 3548, 3540, + 1, 0, 0, 0, 3548, 3549, 1, 0, 0, 0, 3549, 3550, 1, 0, 0, 0, 3550, 3552, + 5, 490, 0, 0, 3551, 3528, 1, 0, 0, 0, 3551, 3529, 1, 0, 0, 0, 3551, 3530, + 1, 0, 0, 0, 3551, 3531, 1, 0, 0, 0, 3551, 3532, 1, 0, 0, 0, 3551, 3533, + 1, 0, 0, 0, 3551, 3534, 1, 0, 0, 0, 3551, 3535, 1, 0, 0, 0, 3551, 3536, + 1, 0, 0, 0, 3551, 3537, 1, 0, 0, 0, 3551, 3538, 1, 0, 0, 0, 3551, 3539, + 1, 0, 0, 0, 3552, 409, 1, 0, 0, 0, 3553, 3554, 5, 489, 0, 0, 3554, 3559, + 3, 412, 206, 0, 3555, 3556, 5, 483, 0, 0, 3556, 3558, 3, 412, 206, 0, 3557, + 3555, 1, 0, 0, 0, 3558, 3561, 1, 0, 0, 0, 3559, 3557, 1, 0, 0, 0, 3559, + 3560, 1, 0, 0, 0, 3560, 3562, 1, 0, 0, 0, 3561, 3559, 1, 0, 0, 0, 3562, + 3563, 5, 490, 0, 0, 3563, 3567, 1, 0, 0, 0, 3564, 3565, 5, 489, 0, 0, 3565, + 3567, 5, 490, 0, 0, 3566, 3553, 1, 0, 0, 0, 3566, 3564, 1, 0, 0, 0, 3567, + 411, 1, 0, 0, 0, 3568, 3569, 5, 499, 0, 0, 3569, 3570, 5, 491, 0, 0, 3570, + 3578, 5, 499, 0, 0, 3571, 3572, 5, 499, 0, 0, 3572, 3573, 5, 491, 0, 0, + 3573, 3578, 5, 92, 0, 0, 3574, 3575, 5, 499, 0, 0, 3575, 3576, 5, 491, + 0, 0, 3576, 3578, 5, 467, 0, 0, 3577, 3568, 1, 0, 0, 0, 3577, 3571, 1, + 0, 0, 0, 3577, 3574, 1, 0, 0, 0, 3578, 413, 1, 0, 0, 0, 3579, 3580, 5, + 487, 0, 0, 3580, 3581, 3, 368, 184, 0, 3581, 3582, 5, 488, 0, 0, 3582, + 415, 1, 0, 0, 0, 3583, 3584, 5, 36, 0, 0, 3584, 3586, 3, 684, 342, 0, 3585, + 3587, 3, 418, 209, 0, 3586, 3585, 1, 0, 0, 0, 3586, 3587, 1, 0, 0, 0, 3587, + 3588, 1, 0, 0, 0, 3588, 3592, 5, 95, 0, 0, 3589, 3591, 3, 422, 211, 0, + 3590, 3589, 1, 0, 0, 0, 3591, 3594, 1, 0, 0, 0, 3592, 3590, 1, 0, 0, 0, + 3592, 3593, 1, 0, 0, 0, 3593, 3595, 1, 0, 0, 0, 3594, 3592, 1, 0, 0, 0, + 3595, 3596, 5, 82, 0, 0, 3596, 417, 1, 0, 0, 0, 3597, 3599, 3, 420, 210, + 0, 3598, 3597, 1, 0, 0, 0, 3599, 3600, 1, 0, 0, 0, 3600, 3598, 1, 0, 0, + 0, 3600, 3601, 1, 0, 0, 0, 3601, 419, 1, 0, 0, 0, 3602, 3603, 5, 394, 0, + 0, 3603, 3604, 5, 499, 0, 0, 3604, 421, 1, 0, 0, 0, 3605, 3606, 5, 33, + 0, 0, 3606, 3609, 3, 684, 342, 0, 3607, 3608, 5, 186, 0, 0, 3608, 3610, + 5, 499, 0, 0, 3609, 3607, 1, 0, 0, 0, 3609, 3610, 1, 0, 0, 0, 3610, 423, + 1, 0, 0, 0, 3611, 3612, 5, 344, 0, 0, 3612, 3613, 5, 343, 0, 0, 3613, 3615, + 3, 684, 342, 0, 3614, 3616, 3, 426, 213, 0, 3615, 3614, 1, 0, 0, 0, 3616, + 3617, 1, 0, 0, 0, 3617, 3615, 1, 0, 0, 0, 3617, 3618, 1, 0, 0, 0, 3618, + 3627, 1, 0, 0, 0, 3619, 3623, 5, 95, 0, 0, 3620, 3622, 3, 428, 214, 0, + 3621, 3620, 1, 0, 0, 0, 3622, 3625, 1, 0, 0, 0, 3623, 3621, 1, 0, 0, 0, + 3623, 3624, 1, 0, 0, 0, 3624, 3626, 1, 0, 0, 0, 3625, 3623, 1, 0, 0, 0, + 3626, 3628, 5, 82, 0, 0, 3627, 3619, 1, 0, 0, 0, 3627, 3628, 1, 0, 0, 0, + 3628, 425, 1, 0, 0, 0, 3629, 3630, 5, 405, 0, 0, 3630, 3657, 5, 499, 0, + 0, 3631, 3632, 5, 343, 0, 0, 3632, 3636, 5, 257, 0, 0, 3633, 3637, 5, 499, + 0, 0, 3634, 3635, 5, 492, 0, 0, 3635, 3637, 3, 684, 342, 0, 3636, 3633, + 1, 0, 0, 0, 3636, 3634, 1, 0, 0, 0, 3637, 3657, 1, 0, 0, 0, 3638, 3639, + 5, 62, 0, 0, 3639, 3657, 5, 499, 0, 0, 3640, 3641, 5, 63, 0, 0, 3641, 3657, + 5, 501, 0, 0, 3642, 3643, 5, 344, 0, 0, 3643, 3657, 5, 499, 0, 0, 3644, + 3648, 5, 341, 0, 0, 3645, 3649, 5, 499, 0, 0, 3646, 3647, 5, 492, 0, 0, + 3647, 3649, 3, 684, 342, 0, 3648, 3645, 1, 0, 0, 0, 3648, 3646, 1, 0, 0, + 0, 3649, 3657, 1, 0, 0, 0, 3650, 3654, 5, 342, 0, 0, 3651, 3655, 5, 499, + 0, 0, 3652, 3653, 5, 492, 0, 0, 3653, 3655, 3, 684, 342, 0, 3654, 3651, + 1, 0, 0, 0, 3654, 3652, 1, 0, 0, 0, 3655, 3657, 1, 0, 0, 0, 3656, 3629, + 1, 0, 0, 0, 3656, 3631, 1, 0, 0, 0, 3656, 3638, 1, 0, 0, 0, 3656, 3640, + 1, 0, 0, 0, 3656, 3642, 1, 0, 0, 0, 3656, 3644, 1, 0, 0, 0, 3656, 3650, + 1, 0, 0, 0, 3657, 427, 1, 0, 0, 0, 3658, 3659, 5, 345, 0, 0, 3659, 3660, + 3, 686, 343, 0, 3660, 3661, 5, 419, 0, 0, 3661, 3673, 7, 25, 0, 0, 3662, + 3663, 5, 359, 0, 0, 3663, 3664, 3, 686, 343, 0, 3664, 3665, 5, 491, 0, + 0, 3665, 3669, 3, 102, 51, 0, 3666, 3667, 5, 290, 0, 0, 3667, 3670, 5, + 499, 0, 0, 3668, 3670, 5, 283, 0, 0, 3669, 3666, 1, 0, 0, 0, 3669, 3668, + 1, 0, 0, 0, 3669, 3670, 1, 0, 0, 0, 3670, 3672, 1, 0, 0, 0, 3671, 3662, + 1, 0, 0, 0, 3672, 3675, 1, 0, 0, 0, 3673, 3671, 1, 0, 0, 0, 3673, 3674, + 1, 0, 0, 0, 3674, 3692, 1, 0, 0, 0, 3675, 3673, 1, 0, 0, 0, 3676, 3677, + 5, 76, 0, 0, 3677, 3690, 3, 684, 342, 0, 3678, 3679, 5, 346, 0, 0, 3679, + 3680, 5, 485, 0, 0, 3680, 3685, 3, 430, 215, 0, 3681, 3682, 5, 483, 0, + 0, 3682, 3684, 3, 430, 215, 0, 3683, 3681, 1, 0, 0, 0, 3684, 3687, 1, 0, + 0, 0, 3685, 3683, 1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, 3688, 1, 0, + 0, 0, 3687, 3685, 1, 0, 0, 0, 3688, 3689, 5, 486, 0, 0, 3689, 3691, 1, + 0, 0, 0, 3690, 3678, 1, 0, 0, 0, 3690, 3691, 1, 0, 0, 0, 3691, 3693, 1, + 0, 0, 0, 3692, 3676, 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 3694, 1, + 0, 0, 0, 3694, 3695, 5, 482, 0, 0, 3695, 429, 1, 0, 0, 0, 3696, 3697, 3, + 686, 343, 0, 3697, 3698, 5, 75, 0, 0, 3698, 3699, 3, 686, 343, 0, 3699, + 431, 1, 0, 0, 0, 3700, 3701, 5, 37, 0, 0, 3701, 3702, 3, 684, 342, 0, 3702, + 3703, 5, 405, 0, 0, 3703, 3704, 3, 102, 51, 0, 3704, 3705, 5, 290, 0, 0, + 3705, 3707, 3, 688, 344, 0, 3706, 3708, 3, 434, 217, 0, 3707, 3706, 1, + 0, 0, 0, 3707, 3708, 1, 0, 0, 0, 3708, 433, 1, 0, 0, 0, 3709, 3711, 3, + 436, 218, 0, 3710, 3709, 1, 0, 0, 0, 3711, 3712, 1, 0, 0, 0, 3712, 3710, + 1, 0, 0, 0, 3712, 3713, 1, 0, 0, 0, 3713, 435, 1, 0, 0, 0, 3714, 3715, + 5, 394, 0, 0, 3715, 3716, 5, 499, 0, 0, 3716, 437, 1, 0, 0, 0, 3717, 3718, + 5, 306, 0, 0, 3718, 3719, 5, 332, 0, 0, 3719, 3720, 3, 684, 342, 0, 3720, + 3721, 3, 440, 220, 0, 3721, 3725, 5, 95, 0, 0, 3722, 3724, 3, 446, 223, + 0, 3723, 3722, 1, 0, 0, 0, 3724, 3727, 1, 0, 0, 0, 3725, 3723, 1, 0, 0, + 0, 3725, 3726, 1, 0, 0, 0, 3726, 3728, 1, 0, 0, 0, 3727, 3725, 1, 0, 0, + 0, 3728, 3729, 5, 82, 0, 0, 3729, 439, 1, 0, 0, 0, 3730, 3732, 3, 442, + 221, 0, 3731, 3730, 1, 0, 0, 0, 3732, 3733, 1, 0, 0, 0, 3733, 3731, 1, + 0, 0, 0, 3733, 3734, 1, 0, 0, 0, 3734, 441, 1, 0, 0, 0, 3735, 3736, 5, + 310, 0, 0, 3736, 3737, 5, 214, 0, 0, 3737, 3745, 5, 499, 0, 0, 3738, 3739, + 5, 319, 0, 0, 3739, 3745, 5, 501, 0, 0, 3740, 3741, 5, 312, 0, 0, 3741, + 3745, 3, 444, 222, 0, 3742, 3743, 5, 394, 0, 0, 3743, 3745, 5, 499, 0, + 0, 3744, 3735, 1, 0, 0, 0, 3744, 3738, 1, 0, 0, 0, 3744, 3740, 1, 0, 0, + 0, 3744, 3742, 1, 0, 0, 0, 3745, 443, 1, 0, 0, 0, 3746, 3747, 5, 313, 0, + 0, 3747, 3748, 5, 341, 0, 0, 3748, 3749, 5, 499, 0, 0, 3749, 3750, 5, 342, + 0, 0, 3750, 3755, 5, 499, 0, 0, 3751, 3752, 5, 315, 0, 0, 3752, 3755, 5, + 499, 0, 0, 3753, 3755, 5, 409, 0, 0, 3754, 3746, 1, 0, 0, 0, 3754, 3751, + 1, 0, 0, 0, 3754, 3753, 1, 0, 0, 0, 3755, 445, 1, 0, 0, 0, 3756, 3757, + 5, 316, 0, 0, 3757, 3758, 5, 503, 0, 0, 3758, 3759, 5, 317, 0, 0, 3759, + 3760, 3, 448, 224, 0, 3760, 3761, 5, 318, 0, 0, 3761, 3763, 5, 499, 0, + 0, 3762, 3764, 3, 450, 225, 0, 3763, 3762, 1, 0, 0, 0, 3763, 3764, 1, 0, + 0, 0, 3764, 447, 1, 0, 0, 0, 3765, 3766, 7, 13, 0, 0, 3766, 449, 1, 0, + 0, 0, 3767, 3769, 3, 452, 226, 0, 3768, 3767, 1, 0, 0, 0, 3769, 3770, 1, + 0, 0, 0, 3770, 3768, 1, 0, 0, 0, 3770, 3771, 1, 0, 0, 0, 3771, 451, 1, + 0, 0, 0, 3772, 3773, 5, 320, 0, 0, 3773, 3781, 5, 499, 0, 0, 3774, 3775, + 5, 321, 0, 0, 3775, 3781, 3, 454, 227, 0, 3776, 3777, 5, 359, 0, 0, 3777, + 3781, 3, 456, 228, 0, 3778, 3779, 5, 319, 0, 0, 3779, 3781, 5, 501, 0, + 0, 3780, 3772, 1, 0, 0, 0, 3780, 3774, 1, 0, 0, 0, 3780, 3776, 1, 0, 0, + 0, 3780, 3778, 1, 0, 0, 0, 3781, 453, 1, 0, 0, 0, 3782, 3783, 5, 325, 0, + 0, 3783, 3784, 5, 501, 0, 0, 3784, 3785, 3, 102, 51, 0, 3785, 455, 1, 0, + 0, 0, 3786, 3787, 5, 503, 0, 0, 3787, 3788, 5, 491, 0, 0, 3788, 3791, 3, + 102, 51, 0, 3789, 3790, 5, 284, 0, 0, 3790, 3792, 7, 26, 0, 0, 3791, 3789, + 1, 0, 0, 0, 3791, 3792, 1, 0, 0, 0, 3792, 457, 1, 0, 0, 0, 3793, 3794, + 5, 41, 0, 0, 3794, 3795, 5, 503, 0, 0, 3795, 3796, 5, 92, 0, 0, 3796, 3797, + 3, 684, 342, 0, 3797, 3798, 5, 485, 0, 0, 3798, 3799, 3, 110, 55, 0, 3799, + 3800, 5, 486, 0, 0, 3800, 459, 1, 0, 0, 0, 3801, 3802, 5, 309, 0, 0, 3802, + 3803, 5, 332, 0, 0, 3803, 3804, 3, 684, 342, 0, 3804, 3805, 5, 485, 0, + 0, 3805, 3810, 3, 466, 233, 0, 3806, 3807, 5, 483, 0, 0, 3807, 3809, 3, + 466, 233, 0, 3808, 3806, 1, 0, 0, 0, 3809, 3812, 1, 0, 0, 0, 3810, 3808, + 1, 0, 0, 0, 3810, 3811, 1, 0, 0, 0, 3811, 3813, 1, 0, 0, 0, 3812, 3810, + 1, 0, 0, 0, 3813, 3815, 5, 486, 0, 0, 3814, 3816, 3, 486, 243, 0, 3815, + 3814, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, 461, 1, 0, 0, 0, 3817, + 3818, 5, 309, 0, 0, 3818, 3819, 5, 307, 0, 0, 3819, 3820, 3, 684, 342, + 0, 3820, 3821, 5, 485, 0, 0, 3821, 3826, 3, 466, 233, 0, 3822, 3823, 5, + 483, 0, 0, 3823, 3825, 3, 466, 233, 0, 3824, 3822, 1, 0, 0, 0, 3825, 3828, + 1, 0, 0, 0, 3826, 3824, 1, 0, 0, 0, 3826, 3827, 1, 0, 0, 0, 3827, 3829, + 1, 0, 0, 0, 3828, 3826, 1, 0, 0, 0, 3829, 3831, 5, 486, 0, 0, 3830, 3832, + 3, 470, 235, 0, 3831, 3830, 1, 0, 0, 0, 3831, 3832, 1, 0, 0, 0, 3832, 3841, + 1, 0, 0, 0, 3833, 3837, 5, 487, 0, 0, 3834, 3836, 3, 474, 237, 0, 3835, + 3834, 1, 0, 0, 0, 3836, 3839, 1, 0, 0, 0, 3837, 3835, 1, 0, 0, 0, 3837, + 3838, 1, 0, 0, 0, 3838, 3840, 1, 0, 0, 0, 3839, 3837, 1, 0, 0, 0, 3840, + 3842, 5, 488, 0, 0, 3841, 3833, 1, 0, 0, 0, 3841, 3842, 1, 0, 0, 0, 3842, + 463, 1, 0, 0, 0, 3843, 3853, 5, 499, 0, 0, 3844, 3853, 5, 501, 0, 0, 3845, + 3853, 5, 291, 0, 0, 3846, 3853, 5, 292, 0, 0, 3847, 3849, 5, 30, 0, 0, + 3848, 3850, 3, 684, 342, 0, 3849, 3848, 1, 0, 0, 0, 3849, 3850, 1, 0, 0, + 0, 3850, 3853, 1, 0, 0, 0, 3851, 3853, 3, 684, 342, 0, 3852, 3843, 1, 0, + 0, 0, 3852, 3844, 1, 0, 0, 0, 3852, 3845, 1, 0, 0, 0, 3852, 3846, 1, 0, + 0, 0, 3852, 3847, 1, 0, 0, 0, 3852, 3851, 1, 0, 0, 0, 3853, 465, 1, 0, + 0, 0, 3854, 3855, 3, 686, 343, 0, 3855, 3856, 5, 491, 0, 0, 3856, 3857, + 3, 464, 232, 0, 3857, 467, 1, 0, 0, 0, 3858, 3859, 3, 686, 343, 0, 3859, + 3860, 5, 472, 0, 0, 3860, 3861, 3, 464, 232, 0, 3861, 469, 1, 0, 0, 0, + 3862, 3863, 5, 312, 0, 0, 3863, 3868, 3, 472, 236, 0, 3864, 3865, 5, 483, + 0, 0, 3865, 3867, 3, 472, 236, 0, 3866, 3864, 1, 0, 0, 0, 3867, 3870, 1, + 0, 0, 0, 3868, 3866, 1, 0, 0, 0, 3868, 3869, 1, 0, 0, 0, 3869, 471, 1, + 0, 0, 0, 3870, 3868, 1, 0, 0, 0, 3871, 3880, 5, 313, 0, 0, 3872, 3880, + 5, 337, 0, 0, 3873, 3880, 5, 338, 0, 0, 3874, 3876, 5, 30, 0, 0, 3875, + 3877, 3, 684, 342, 0, 3876, 3875, 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, + 3880, 1, 0, 0, 0, 3878, 3880, 5, 503, 0, 0, 3879, 3871, 1, 0, 0, 0, 3879, + 3872, 1, 0, 0, 0, 3879, 3873, 1, 0, 0, 0, 3879, 3874, 1, 0, 0, 0, 3879, + 3878, 1, 0, 0, 0, 3880, 473, 1, 0, 0, 0, 3881, 3882, 5, 334, 0, 0, 3882, + 3883, 5, 23, 0, 0, 3883, 3886, 3, 684, 342, 0, 3884, 3885, 5, 75, 0, 0, + 3885, 3887, 5, 499, 0, 0, 3886, 3884, 1, 0, 0, 0, 3886, 3887, 1, 0, 0, + 0, 3887, 3899, 1, 0, 0, 0, 3888, 3889, 5, 485, 0, 0, 3889, 3894, 3, 466, + 233, 0, 3890, 3891, 5, 483, 0, 0, 3891, 3893, 3, 466, 233, 0, 3892, 3890, + 1, 0, 0, 0, 3893, 3896, 1, 0, 0, 0, 3894, 3892, 1, 0, 0, 0, 3894, 3895, + 1, 0, 0, 0, 3895, 3897, 1, 0, 0, 0, 3896, 3894, 1, 0, 0, 0, 3897, 3898, + 5, 486, 0, 0, 3898, 3900, 1, 0, 0, 0, 3899, 3888, 1, 0, 0, 0, 3899, 3900, + 1, 0, 0, 0, 3900, 3902, 1, 0, 0, 0, 3901, 3903, 3, 476, 238, 0, 3902, 3901, + 1, 0, 0, 0, 3902, 3903, 1, 0, 0, 0, 3903, 3905, 1, 0, 0, 0, 3904, 3906, + 5, 482, 0, 0, 3905, 3904, 1, 0, 0, 0, 3905, 3906, 1, 0, 0, 0, 3906, 475, + 1, 0, 0, 0, 3907, 3908, 5, 335, 0, 0, 3908, 3918, 5, 485, 0, 0, 3909, 3919, + 5, 477, 0, 0, 3910, 3915, 3, 478, 239, 0, 3911, 3912, 5, 483, 0, 0, 3912, + 3914, 3, 478, 239, 0, 3913, 3911, 1, 0, 0, 0, 3914, 3917, 1, 0, 0, 0, 3915, + 3913, 1, 0, 0, 0, 3915, 3916, 1, 0, 0, 0, 3916, 3919, 1, 0, 0, 0, 3917, + 3915, 1, 0, 0, 0, 3918, 3909, 1, 0, 0, 0, 3918, 3910, 1, 0, 0, 0, 3919, + 3920, 1, 0, 0, 0, 3920, 3921, 5, 486, 0, 0, 3921, 477, 1, 0, 0, 0, 3922, + 3925, 5, 503, 0, 0, 3923, 3924, 5, 75, 0, 0, 3924, 3926, 5, 499, 0, 0, + 3925, 3923, 1, 0, 0, 0, 3925, 3926, 1, 0, 0, 0, 3926, 3928, 1, 0, 0, 0, + 3927, 3929, 3, 480, 240, 0, 3928, 3927, 1, 0, 0, 0, 3928, 3929, 1, 0, 0, + 0, 3929, 479, 1, 0, 0, 0, 3930, 3931, 5, 485, 0, 0, 3931, 3936, 5, 503, + 0, 0, 3932, 3933, 5, 483, 0, 0, 3933, 3935, 5, 503, 0, 0, 3934, 3932, 1, + 0, 0, 0, 3935, 3938, 1, 0, 0, 0, 3936, 3934, 1, 0, 0, 0, 3936, 3937, 1, + 0, 0, 0, 3937, 3939, 1, 0, 0, 0, 3938, 3936, 1, 0, 0, 0, 3939, 3940, 5, + 486, 0, 0, 3940, 481, 1, 0, 0, 0, 3941, 3942, 5, 26, 0, 0, 3942, 3943, + 5, 23, 0, 0, 3943, 3944, 3, 684, 342, 0, 3944, 3945, 5, 70, 0, 0, 3945, + 3946, 5, 309, 0, 0, 3946, 3947, 5, 332, 0, 0, 3947, 3948, 3, 684, 342, + 0, 3948, 3949, 5, 485, 0, 0, 3949, 3954, 3, 466, 233, 0, 3950, 3951, 5, + 483, 0, 0, 3951, 3953, 3, 466, 233, 0, 3952, 3950, 1, 0, 0, 0, 3953, 3956, + 1, 0, 0, 0, 3954, 3952, 1, 0, 0, 0, 3954, 3955, 1, 0, 0, 0, 3955, 3957, + 1, 0, 0, 0, 3956, 3954, 1, 0, 0, 0, 3957, 3963, 5, 486, 0, 0, 3958, 3960, + 5, 485, 0, 0, 3959, 3961, 3, 94, 47, 0, 3960, 3959, 1, 0, 0, 0, 3960, 3961, + 1, 0, 0, 0, 3961, 3962, 1, 0, 0, 0, 3962, 3964, 5, 486, 0, 0, 3963, 3958, + 1, 0, 0, 0, 3963, 3964, 1, 0, 0, 0, 3964, 483, 1, 0, 0, 0, 3965, 3968, + 5, 362, 0, 0, 3966, 3969, 3, 684, 342, 0, 3967, 3969, 5, 503, 0, 0, 3968, + 3966, 1, 0, 0, 0, 3968, 3967, 1, 0, 0, 0, 3969, 3973, 1, 0, 0, 0, 3970, + 3972, 3, 28, 14, 0, 3971, 3970, 1, 0, 0, 0, 3972, 3975, 1, 0, 0, 0, 3973, + 3971, 1, 0, 0, 0, 3973, 3974, 1, 0, 0, 0, 3974, 485, 1, 0, 0, 0, 3975, + 3973, 1, 0, 0, 0, 3976, 3977, 5, 361, 0, 0, 3977, 3978, 5, 485, 0, 0, 3978, + 3983, 3, 488, 244, 0, 3979, 3980, 5, 483, 0, 0, 3980, 3982, 3, 488, 244, + 0, 3981, 3979, 1, 0, 0, 0, 3982, 3985, 1, 0, 0, 0, 3983, 3981, 1, 0, 0, + 0, 3983, 3984, 1, 0, 0, 0, 3984, 3986, 1, 0, 0, 0, 3985, 3983, 1, 0, 0, + 0, 3986, 3987, 5, 486, 0, 0, 3987, 487, 1, 0, 0, 0, 3988, 3989, 5, 499, + 0, 0, 3989, 3990, 5, 491, 0, 0, 3990, 3991, 3, 464, 232, 0, 3991, 489, + 1, 0, 0, 0, 3992, 3993, 5, 425, 0, 0, 3993, 3994, 5, 426, 0, 0, 3994, 3995, + 5, 307, 0, 0, 3995, 3996, 3, 684, 342, 0, 3996, 3997, 5, 485, 0, 0, 3997, + 4002, 3, 466, 233, 0, 3998, 3999, 5, 483, 0, 0, 3999, 4001, 3, 466, 233, + 0, 4000, 3998, 1, 0, 0, 0, 4001, 4004, 1, 0, 0, 0, 4002, 4000, 1, 0, 0, + 0, 4002, 4003, 1, 0, 0, 0, 4003, 4005, 1, 0, 0, 0, 4004, 4002, 1, 0, 0, + 0, 4005, 4006, 5, 486, 0, 0, 4006, 4008, 5, 487, 0, 0, 4007, 4009, 3, 492, + 246, 0, 4008, 4007, 1, 0, 0, 0, 4009, 4010, 1, 0, 0, 0, 4010, 4008, 1, + 0, 0, 0, 4010, 4011, 1, 0, 0, 0, 4011, 4012, 1, 0, 0, 0, 4012, 4013, 5, + 488, 0, 0, 4013, 491, 1, 0, 0, 0, 4014, 4015, 5, 393, 0, 0, 4015, 4016, + 5, 503, 0, 0, 4016, 4017, 5, 485, 0, 0, 4017, 4022, 3, 494, 247, 0, 4018, + 4019, 5, 483, 0, 0, 4019, 4021, 3, 494, 247, 0, 4020, 4018, 1, 0, 0, 0, + 4021, 4024, 1, 0, 0, 0, 4022, 4020, 1, 0, 0, 0, 4022, 4023, 1, 0, 0, 0, + 4023, 4025, 1, 0, 0, 0, 4024, 4022, 1, 0, 0, 0, 4025, 4026, 5, 486, 0, + 0, 4026, 4029, 7, 27, 0, 0, 4027, 4028, 5, 23, 0, 0, 4028, 4030, 3, 684, + 342, 0, 4029, 4027, 1, 0, 0, 0, 4029, 4030, 1, 0, 0, 0, 4030, 4033, 1, + 0, 0, 0, 4031, 4032, 5, 30, 0, 0, 4032, 4034, 3, 684, 342, 0, 4033, 4031, + 1, 0, 0, 0, 4033, 4034, 1, 0, 0, 0, 4034, 4035, 1, 0, 0, 0, 4035, 4036, + 5, 482, 0, 0, 4036, 493, 1, 0, 0, 0, 4037, 4038, 5, 503, 0, 0, 4038, 4039, + 5, 491, 0, 0, 4039, 4040, 3, 102, 51, 0, 4040, 495, 1, 0, 0, 0, 4041, 4042, + 5, 32, 0, 0, 4042, 4047, 3, 684, 342, 0, 4043, 4044, 5, 359, 0, 0, 4044, + 4045, 5, 502, 0, 0, 4045, 4046, 5, 491, 0, 0, 4046, 4048, 3, 684, 342, + 0, 4047, 4043, 1, 0, 0, 0, 4047, 4048, 1, 0, 0, 0, 4048, 4051, 1, 0, 0, + 0, 4049, 4050, 5, 466, 0, 0, 4050, 4052, 5, 499, 0, 0, 4051, 4049, 1, 0, + 0, 0, 4051, 4052, 1, 0, 0, 0, 4052, 4055, 1, 0, 0, 0, 4053, 4054, 5, 465, + 0, 0, 4054, 4056, 5, 499, 0, 0, 4055, 4053, 1, 0, 0, 0, 4055, 4056, 1, + 0, 0, 0, 4056, 4060, 1, 0, 0, 0, 4057, 4058, 5, 352, 0, 0, 4058, 4059, + 5, 442, 0, 0, 4059, 4061, 7, 28, 0, 0, 4060, 4057, 1, 0, 0, 0, 4060, 4061, + 1, 0, 0, 0, 4061, 4065, 1, 0, 0, 0, 4062, 4063, 5, 453, 0, 0, 4063, 4064, + 5, 33, 0, 0, 4064, 4066, 3, 684, 342, 0, 4065, 4062, 1, 0, 0, 0, 4065, + 4066, 1, 0, 0, 0, 4066, 4070, 1, 0, 0, 0, 4067, 4068, 5, 452, 0, 0, 4068, + 4069, 5, 263, 0, 0, 4069, 4071, 5, 499, 0, 0, 4070, 4067, 1, 0, 0, 0, 4070, + 4071, 1, 0, 0, 0, 4071, 4072, 1, 0, 0, 0, 4072, 4073, 5, 95, 0, 0, 4073, + 4074, 3, 498, 249, 0, 4074, 4075, 5, 82, 0, 0, 4075, 4077, 5, 32, 0, 0, + 4076, 4078, 5, 482, 0, 0, 4077, 4076, 1, 0, 0, 0, 4077, 4078, 1, 0, 0, + 0, 4078, 4080, 1, 0, 0, 0, 4079, 4081, 5, 478, 0, 0, 4080, 4079, 1, 0, + 0, 0, 4080, 4081, 1, 0, 0, 0, 4081, 497, 1, 0, 0, 0, 4082, 4084, 3, 500, + 250, 0, 4083, 4082, 1, 0, 0, 0, 4084, 4087, 1, 0, 0, 0, 4085, 4083, 1, + 0, 0, 0, 4085, 4086, 1, 0, 0, 0, 4086, 499, 1, 0, 0, 0, 4087, 4085, 1, + 0, 0, 0, 4088, 4089, 3, 502, 251, 0, 4089, 4090, 5, 482, 0, 0, 4090, 4116, + 1, 0, 0, 0, 4091, 4092, 3, 508, 254, 0, 4092, 4093, 5, 482, 0, 0, 4093, + 4116, 1, 0, 0, 0, 4094, 4095, 3, 512, 256, 0, 4095, 4096, 5, 482, 0, 0, + 4096, 4116, 1, 0, 0, 0, 4097, 4098, 3, 514, 257, 0, 4098, 4099, 5, 482, + 0, 0, 4099, 4116, 1, 0, 0, 0, 4100, 4101, 3, 518, 259, 0, 4101, 4102, 5, + 482, 0, 0, 4102, 4116, 1, 0, 0, 0, 4103, 4104, 3, 522, 261, 0, 4104, 4105, + 5, 482, 0, 0, 4105, 4116, 1, 0, 0, 0, 4106, 4107, 3, 524, 262, 0, 4107, + 4108, 5, 482, 0, 0, 4108, 4116, 1, 0, 0, 0, 4109, 4110, 3, 526, 263, 0, + 4110, 4111, 5, 482, 0, 0, 4111, 4116, 1, 0, 0, 0, 4112, 4113, 3, 528, 264, + 0, 4113, 4114, 5, 482, 0, 0, 4114, 4116, 1, 0, 0, 0, 4115, 4088, 1, 0, + 0, 0, 4115, 4091, 1, 0, 0, 0, 4115, 4094, 1, 0, 0, 0, 4115, 4097, 1, 0, + 0, 0, 4115, 4100, 1, 0, 0, 0, 4115, 4103, 1, 0, 0, 0, 4115, 4106, 1, 0, + 0, 0, 4115, 4109, 1, 0, 0, 0, 4115, 4112, 1, 0, 0, 0, 4116, 501, 1, 0, + 0, 0, 4117, 4118, 5, 443, 0, 0, 4118, 4119, 5, 444, 0, 0, 4119, 4120, 5, + 503, 0, 0, 4120, 4123, 5, 499, 0, 0, 4121, 4122, 5, 33, 0, 0, 4122, 4124, + 3, 684, 342, 0, 4123, 4121, 1, 0, 0, 0, 4123, 4124, 1, 0, 0, 0, 4124, 4128, + 1, 0, 0, 0, 4125, 4126, 5, 448, 0, 0, 4126, 4127, 5, 30, 0, 0, 4127, 4129, + 3, 684, 342, 0, 4128, 4125, 1, 0, 0, 0, 4128, 4129, 1, 0, 0, 0, 4129, 4133, + 1, 0, 0, 0, 4130, 4131, 5, 448, 0, 0, 4131, 4132, 5, 303, 0, 0, 4132, 4134, + 5, 499, 0, 0, 4133, 4130, 1, 0, 0, 0, 4133, 4134, 1, 0, 0, 0, 4134, 4137, + 1, 0, 0, 0, 4135, 4136, 5, 23, 0, 0, 4136, 4138, 3, 684, 342, 0, 4137, + 4135, 1, 0, 0, 0, 4137, 4138, 1, 0, 0, 0, 4138, 4142, 1, 0, 0, 0, 4139, + 4140, 5, 452, 0, 0, 4140, 4141, 5, 263, 0, 0, 4141, 4143, 5, 499, 0, 0, + 4142, 4139, 1, 0, 0, 0, 4142, 4143, 1, 0, 0, 0, 4143, 4146, 1, 0, 0, 0, + 4144, 4145, 5, 465, 0, 0, 4145, 4147, 5, 499, 0, 0, 4146, 4144, 1, 0, 0, + 0, 4146, 4147, 1, 0, 0, 0, 4147, 4154, 1, 0, 0, 0, 4148, 4150, 5, 447, + 0, 0, 4149, 4151, 3, 506, 253, 0, 4150, 4149, 1, 0, 0, 0, 4151, 4152, 1, + 0, 0, 0, 4152, 4150, 1, 0, 0, 0, 4152, 4153, 1, 0, 0, 0, 4153, 4155, 1, + 0, 0, 0, 4154, 4148, 1, 0, 0, 0, 4154, 4155, 1, 0, 0, 0, 4155, 4163, 1, + 0, 0, 0, 4156, 4157, 5, 458, 0, 0, 4157, 4159, 5, 426, 0, 0, 4158, 4160, + 3, 504, 252, 0, 4159, 4158, 1, 0, 0, 0, 4160, 4161, 1, 0, 0, 0, 4161, 4159, + 1, 0, 0, 0, 4161, 4162, 1, 0, 0, 0, 4162, 4164, 1, 0, 0, 0, 4163, 4156, + 1, 0, 0, 0, 4163, 4164, 1, 0, 0, 0, 4164, 4215, 1, 0, 0, 0, 4165, 4166, + 5, 461, 0, 0, 4166, 4167, 5, 443, 0, 0, 4167, 4168, 5, 444, 0, 0, 4168, + 4169, 5, 503, 0, 0, 4169, 4172, 5, 499, 0, 0, 4170, 4171, 5, 33, 0, 0, + 4171, 4173, 3, 684, 342, 0, 4172, 4170, 1, 0, 0, 0, 4172, 4173, 1, 0, 0, + 0, 4173, 4177, 1, 0, 0, 0, 4174, 4175, 5, 448, 0, 0, 4175, 4176, 5, 30, + 0, 0, 4176, 4178, 3, 684, 342, 0, 4177, 4174, 1, 0, 0, 0, 4177, 4178, 1, + 0, 0, 0, 4178, 4182, 1, 0, 0, 0, 4179, 4180, 5, 448, 0, 0, 4180, 4181, + 5, 303, 0, 0, 4181, 4183, 5, 499, 0, 0, 4182, 4179, 1, 0, 0, 0, 4182, 4183, + 1, 0, 0, 0, 4183, 4186, 1, 0, 0, 0, 4184, 4185, 5, 23, 0, 0, 4185, 4187, + 3, 684, 342, 0, 4186, 4184, 1, 0, 0, 0, 4186, 4187, 1, 0, 0, 0, 4187, 4191, + 1, 0, 0, 0, 4188, 4189, 5, 452, 0, 0, 4189, 4190, 5, 263, 0, 0, 4190, 4192, + 5, 499, 0, 0, 4191, 4188, 1, 0, 0, 0, 4191, 4192, 1, 0, 0, 0, 4192, 4195, + 1, 0, 0, 0, 4193, 4194, 5, 465, 0, 0, 4194, 4196, 5, 499, 0, 0, 4195, 4193, + 1, 0, 0, 0, 4195, 4196, 1, 0, 0, 0, 4196, 4203, 1, 0, 0, 0, 4197, 4199, + 5, 447, 0, 0, 4198, 4200, 3, 506, 253, 0, 4199, 4198, 1, 0, 0, 0, 4200, + 4201, 1, 0, 0, 0, 4201, 4199, 1, 0, 0, 0, 4201, 4202, 1, 0, 0, 0, 4202, + 4204, 1, 0, 0, 0, 4203, 4197, 1, 0, 0, 0, 4203, 4204, 1, 0, 0, 0, 4204, + 4212, 1, 0, 0, 0, 4205, 4206, 5, 458, 0, 0, 4206, 4208, 5, 426, 0, 0, 4207, + 4209, 3, 504, 252, 0, 4208, 4207, 1, 0, 0, 0, 4209, 4210, 1, 0, 0, 0, 4210, + 4208, 1, 0, 0, 0, 4210, 4211, 1, 0, 0, 0, 4211, 4213, 1, 0, 0, 0, 4212, + 4205, 1, 0, 0, 0, 4212, 4213, 1, 0, 0, 0, 4213, 4215, 1, 0, 0, 0, 4214, + 4117, 1, 0, 0, 0, 4214, 4165, 1, 0, 0, 0, 4215, 503, 1, 0, 0, 0, 4216, + 4217, 5, 459, 0, 0, 4217, 4219, 5, 450, 0, 0, 4218, 4220, 5, 499, 0, 0, + 4219, 4218, 1, 0, 0, 0, 4219, 4220, 1, 0, 0, 0, 4220, 4225, 1, 0, 0, 0, + 4221, 4222, 5, 487, 0, 0, 4222, 4223, 3, 498, 249, 0, 4223, 4224, 5, 488, + 0, 0, 4224, 4226, 1, 0, 0, 0, 4225, 4221, 1, 0, 0, 0, 4225, 4226, 1, 0, + 0, 0, 4226, 4250, 1, 0, 0, 0, 4227, 4228, 5, 460, 0, 0, 4228, 4229, 5, + 459, 0, 0, 4229, 4231, 5, 450, 0, 0, 4230, 4232, 5, 499, 0, 0, 4231, 4230, + 1, 0, 0, 0, 4231, 4232, 1, 0, 0, 0, 4232, 4237, 1, 0, 0, 0, 4233, 4234, + 5, 487, 0, 0, 4234, 4235, 3, 498, 249, 0, 4235, 4236, 5, 488, 0, 0, 4236, + 4238, 1, 0, 0, 0, 4237, 4233, 1, 0, 0, 0, 4237, 4238, 1, 0, 0, 0, 4238, + 4250, 1, 0, 0, 0, 4239, 4241, 5, 450, 0, 0, 4240, 4242, 5, 499, 0, 0, 4241, + 4240, 1, 0, 0, 0, 4241, 4242, 1, 0, 0, 0, 4242, 4247, 1, 0, 0, 0, 4243, + 4244, 5, 487, 0, 0, 4244, 4245, 3, 498, 249, 0, 4245, 4246, 5, 488, 0, + 0, 4246, 4248, 1, 0, 0, 0, 4247, 4243, 1, 0, 0, 0, 4247, 4248, 1, 0, 0, + 0, 4248, 4250, 1, 0, 0, 0, 4249, 4216, 1, 0, 0, 0, 4249, 4227, 1, 0, 0, + 0, 4249, 4239, 1, 0, 0, 0, 4250, 505, 1, 0, 0, 0, 4251, 4252, 5, 499, 0, + 0, 4252, 4253, 5, 487, 0, 0, 4253, 4254, 3, 498, 249, 0, 4254, 4255, 5, + 488, 0, 0, 4255, 507, 1, 0, 0, 0, 4256, 4257, 5, 112, 0, 0, 4257, 4258, + 5, 30, 0, 0, 4258, 4261, 3, 684, 342, 0, 4259, 4260, 5, 394, 0, 0, 4260, + 4262, 5, 499, 0, 0, 4261, 4259, 1, 0, 0, 0, 4261, 4262, 1, 0, 0, 0, 4262, + 4275, 1, 0, 0, 0, 4263, 4264, 5, 137, 0, 0, 4264, 4265, 5, 485, 0, 0, 4265, + 4270, 3, 510, 255, 0, 4266, 4267, 5, 483, 0, 0, 4267, 4269, 3, 510, 255, + 0, 4268, 4266, 1, 0, 0, 0, 4269, 4272, 1, 0, 0, 0, 4270, 4268, 1, 0, 0, + 0, 4270, 4271, 1, 0, 0, 0, 4271, 4273, 1, 0, 0, 0, 4272, 4270, 1, 0, 0, + 0, 4273, 4274, 5, 486, 0, 0, 4274, 4276, 1, 0, 0, 0, 4275, 4263, 1, 0, + 0, 0, 4275, 4276, 1, 0, 0, 0, 4276, 4283, 1, 0, 0, 0, 4277, 4279, 5, 447, + 0, 0, 4278, 4280, 3, 516, 258, 0, 4279, 4278, 1, 0, 0, 0, 4280, 4281, 1, + 0, 0, 0, 4281, 4279, 1, 0, 0, 0, 4281, 4282, 1, 0, 0, 0, 4282, 4284, 1, + 0, 0, 0, 4283, 4277, 1, 0, 0, 0, 4283, 4284, 1, 0, 0, 0, 4284, 4292, 1, + 0, 0, 0, 4285, 4286, 5, 458, 0, 0, 4286, 4288, 5, 426, 0, 0, 4287, 4289, + 3, 504, 252, 0, 4288, 4287, 1, 0, 0, 0, 4289, 4290, 1, 0, 0, 0, 4290, 4288, + 1, 0, 0, 0, 4290, 4291, 1, 0, 0, 0, 4291, 4293, 1, 0, 0, 0, 4292, 4285, + 1, 0, 0, 0, 4292, 4293, 1, 0, 0, 0, 4293, 509, 1, 0, 0, 0, 4294, 4295, + 3, 684, 342, 0, 4295, 4296, 5, 472, 0, 0, 4296, 4297, 5, 499, 0, 0, 4297, + 511, 1, 0, 0, 0, 4298, 4299, 5, 112, 0, 0, 4299, 4300, 5, 32, 0, 0, 4300, + 4303, 3, 684, 342, 0, 4301, 4302, 5, 394, 0, 0, 4302, 4304, 5, 499, 0, + 0, 4303, 4301, 1, 0, 0, 0, 4303, 4304, 1, 0, 0, 0, 4304, 4317, 1, 0, 0, + 0, 4305, 4306, 5, 137, 0, 0, 4306, 4307, 5, 485, 0, 0, 4307, 4312, 3, 510, + 255, 0, 4308, 4309, 5, 483, 0, 0, 4309, 4311, 3, 510, 255, 0, 4310, 4308, + 1, 0, 0, 0, 4311, 4314, 1, 0, 0, 0, 4312, 4310, 1, 0, 0, 0, 4312, 4313, + 1, 0, 0, 0, 4313, 4315, 1, 0, 0, 0, 4314, 4312, 1, 0, 0, 0, 4315, 4316, + 5, 486, 0, 0, 4316, 4318, 1, 0, 0, 0, 4317, 4305, 1, 0, 0, 0, 4317, 4318, + 1, 0, 0, 0, 4318, 513, 1, 0, 0, 0, 4319, 4321, 5, 445, 0, 0, 4320, 4322, + 5, 499, 0, 0, 4321, 4320, 1, 0, 0, 0, 4321, 4322, 1, 0, 0, 0, 4322, 4325, + 1, 0, 0, 0, 4323, 4324, 5, 394, 0, 0, 4324, 4326, 5, 499, 0, 0, 4325, 4323, + 1, 0, 0, 0, 4325, 4326, 1, 0, 0, 0, 4326, 4333, 1, 0, 0, 0, 4327, 4329, + 5, 447, 0, 0, 4328, 4330, 3, 516, 258, 0, 4329, 4328, 1, 0, 0, 0, 4330, + 4331, 1, 0, 0, 0, 4331, 4329, 1, 0, 0, 0, 4331, 4332, 1, 0, 0, 0, 4332, + 4334, 1, 0, 0, 0, 4333, 4327, 1, 0, 0, 0, 4333, 4334, 1, 0, 0, 0, 4334, + 515, 1, 0, 0, 0, 4335, 4336, 7, 29, 0, 0, 4336, 4337, 5, 495, 0, 0, 4337, + 4338, 5, 487, 0, 0, 4338, 4339, 3, 498, 249, 0, 4339, 4340, 5, 488, 0, + 0, 4340, 517, 1, 0, 0, 0, 4341, 4342, 5, 455, 0, 0, 4342, 4345, 5, 446, + 0, 0, 4343, 4344, 5, 394, 0, 0, 4344, 4346, 5, 499, 0, 0, 4345, 4343, 1, + 0, 0, 0, 4345, 4346, 1, 0, 0, 0, 4346, 4348, 1, 0, 0, 0, 4347, 4349, 3, + 520, 260, 0, 4348, 4347, 1, 0, 0, 0, 4349, 4350, 1, 0, 0, 0, 4350, 4348, + 1, 0, 0, 0, 4350, 4351, 1, 0, 0, 0, 4351, 519, 1, 0, 0, 0, 4352, 4353, + 5, 318, 0, 0, 4353, 4354, 5, 501, 0, 0, 4354, 4355, 5, 487, 0, 0, 4355, + 4356, 3, 498, 249, 0, 4356, 4357, 5, 488, 0, 0, 4357, 521, 1, 0, 0, 0, + 4358, 4359, 5, 451, 0, 0, 4359, 4360, 5, 411, 0, 0, 4360, 4363, 5, 503, + 0, 0, 4361, 4362, 5, 394, 0, 0, 4362, 4364, 5, 499, 0, 0, 4363, 4361, 1, + 0, 0, 0, 4363, 4364, 1, 0, 0, 0, 4364, 523, 1, 0, 0, 0, 4365, 4366, 5, + 456, 0, 0, 4366, 4367, 5, 414, 0, 0, 4367, 4369, 5, 450, 0, 0, 4368, 4370, + 5, 499, 0, 0, 4369, 4368, 1, 0, 0, 0, 4369, 4370, 1, 0, 0, 0, 4370, 4373, + 1, 0, 0, 0, 4371, 4372, 5, 394, 0, 0, 4372, 4374, 5, 499, 0, 0, 4373, 4371, + 1, 0, 0, 0, 4373, 4374, 1, 0, 0, 0, 4374, 525, 1, 0, 0, 0, 4375, 4376, + 5, 456, 0, 0, 4376, 4377, 5, 414, 0, 0, 4377, 4380, 5, 449, 0, 0, 4378, + 4379, 5, 394, 0, 0, 4379, 4381, 5, 499, 0, 0, 4380, 4378, 1, 0, 0, 0, 4380, + 4381, 1, 0, 0, 0, 4381, 4389, 1, 0, 0, 0, 4382, 4383, 5, 458, 0, 0, 4383, + 4385, 5, 426, 0, 0, 4384, 4386, 3, 504, 252, 0, 4385, 4384, 1, 0, 0, 0, + 4386, 4387, 1, 0, 0, 0, 4387, 4385, 1, 0, 0, 0, 4387, 4388, 1, 0, 0, 0, + 4388, 4390, 1, 0, 0, 0, 4389, 4382, 1, 0, 0, 0, 4389, 4390, 1, 0, 0, 0, + 4390, 527, 1, 0, 0, 0, 4391, 4392, 5, 457, 0, 0, 4392, 4393, 5, 499, 0, + 0, 4393, 529, 1, 0, 0, 0, 4394, 4395, 3, 532, 266, 0, 4395, 4400, 3, 534, + 267, 0, 4396, 4397, 5, 483, 0, 0, 4397, 4399, 3, 534, 267, 0, 4398, 4396, + 1, 0, 0, 0, 4399, 4402, 1, 0, 0, 0, 4400, 4398, 1, 0, 0, 0, 4400, 4401, + 1, 0, 0, 0, 4401, 4423, 1, 0, 0, 0, 4402, 4400, 1, 0, 0, 0, 4403, 4404, + 5, 37, 0, 0, 4404, 4405, 5, 499, 0, 0, 4405, 4406, 5, 406, 0, 0, 4406, + 4410, 3, 536, 268, 0, 4407, 4408, 5, 284, 0, 0, 4408, 4409, 5, 429, 0, + 0, 4409, 4411, 5, 499, 0, 0, 4410, 4407, 1, 0, 0, 0, 4410, 4411, 1, 0, + 0, 0, 4411, 4423, 1, 0, 0, 0, 4412, 4413, 5, 429, 0, 0, 4413, 4414, 5, + 499, 0, 0, 4414, 4419, 3, 534, 267, 0, 4415, 4416, 5, 483, 0, 0, 4416, + 4418, 3, 534, 267, 0, 4417, 4415, 1, 0, 0, 0, 4418, 4421, 1, 0, 0, 0, 4419, + 4417, 1, 0, 0, 0, 4419, 4420, 1, 0, 0, 0, 4420, 4423, 1, 0, 0, 0, 4421, + 4419, 1, 0, 0, 0, 4422, 4394, 1, 0, 0, 0, 4422, 4403, 1, 0, 0, 0, 4422, + 4412, 1, 0, 0, 0, 4423, 531, 1, 0, 0, 0, 4424, 4425, 7, 30, 0, 0, 4425, + 533, 1, 0, 0, 0, 4426, 4427, 5, 503, 0, 0, 4427, 4428, 5, 472, 0, 0, 4428, + 4429, 3, 536, 268, 0, 4429, 535, 1, 0, 0, 0, 4430, 4435, 5, 499, 0, 0, + 4431, 4435, 5, 501, 0, 0, 4432, 4435, 3, 692, 346, 0, 4433, 4435, 3, 684, + 342, 0, 4434, 4430, 1, 0, 0, 0, 4434, 4431, 1, 0, 0, 0, 4434, 4432, 1, + 0, 0, 0, 4434, 4433, 1, 0, 0, 0, 4435, 537, 1, 0, 0, 0, 4436, 4441, 3, + 540, 270, 0, 4437, 4441, 3, 552, 276, 0, 4438, 4441, 3, 554, 277, 0, 4439, + 4441, 3, 560, 280, 0, 4440, 4436, 1, 0, 0, 0, 4440, 4437, 1, 0, 0, 0, 4440, + 4438, 1, 0, 0, 0, 4440, 4439, 1, 0, 0, 0, 4441, 539, 1, 0, 0, 0, 4442, + 4443, 5, 64, 0, 0, 4443, 4769, 5, 368, 0, 0, 4444, 4445, 5, 64, 0, 0, 4445, + 4451, 5, 369, 0, 0, 4446, 4449, 5, 284, 0, 0, 4447, 4450, 3, 684, 342, + 0, 4448, 4450, 5, 503, 0, 0, 4449, 4447, 1, 0, 0, 0, 4449, 4448, 1, 0, + 0, 0, 4450, 4452, 1, 0, 0, 0, 4451, 4446, 1, 0, 0, 0, 4451, 4452, 1, 0, + 0, 0, 4452, 4769, 1, 0, 0, 0, 4453, 4454, 5, 64, 0, 0, 4454, 4460, 5, 370, + 0, 0, 4455, 4458, 5, 284, 0, 0, 4456, 4459, 3, 684, 342, 0, 4457, 4459, + 5, 503, 0, 0, 4458, 4456, 1, 0, 0, 0, 4458, 4457, 1, 0, 0, 0, 4459, 4461, + 1, 0, 0, 0, 4460, 4455, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, 4769, + 1, 0, 0, 0, 4462, 4463, 5, 64, 0, 0, 4463, 4469, 5, 371, 0, 0, 4464, 4467, + 5, 284, 0, 0, 4465, 4468, 3, 684, 342, 0, 4466, 4468, 5, 503, 0, 0, 4467, + 4465, 1, 0, 0, 0, 4467, 4466, 1, 0, 0, 0, 4468, 4470, 1, 0, 0, 0, 4469, + 4464, 1, 0, 0, 0, 4469, 4470, 1, 0, 0, 0, 4470, 4769, 1, 0, 0, 0, 4471, + 4472, 5, 64, 0, 0, 4472, 4478, 5, 372, 0, 0, 4473, 4476, 5, 284, 0, 0, + 4474, 4477, 3, 684, 342, 0, 4475, 4477, 5, 503, 0, 0, 4476, 4474, 1, 0, + 0, 0, 4476, 4475, 1, 0, 0, 0, 4477, 4479, 1, 0, 0, 0, 4478, 4473, 1, 0, + 0, 0, 4478, 4479, 1, 0, 0, 0, 4479, 4769, 1, 0, 0, 0, 4480, 4481, 5, 64, + 0, 0, 4481, 4487, 5, 373, 0, 0, 4482, 4485, 5, 284, 0, 0, 4483, 4486, 3, + 684, 342, 0, 4484, 4486, 5, 503, 0, 0, 4485, 4483, 1, 0, 0, 0, 4485, 4484, + 1, 0, 0, 0, 4486, 4488, 1, 0, 0, 0, 4487, 4482, 1, 0, 0, 0, 4487, 4488, + 1, 0, 0, 0, 4488, 4769, 1, 0, 0, 0, 4489, 4490, 5, 64, 0, 0, 4490, 4496, + 5, 141, 0, 0, 4491, 4494, 5, 284, 0, 0, 4492, 4495, 3, 684, 342, 0, 4493, + 4495, 5, 503, 0, 0, 4494, 4492, 1, 0, 0, 0, 4494, 4493, 1, 0, 0, 0, 4495, + 4497, 1, 0, 0, 0, 4496, 4491, 1, 0, 0, 0, 4496, 4497, 1, 0, 0, 0, 4497, + 4769, 1, 0, 0, 0, 4498, 4499, 5, 64, 0, 0, 4499, 4505, 5, 143, 0, 0, 4500, + 4503, 5, 284, 0, 0, 4501, 4504, 3, 684, 342, 0, 4502, 4504, 5, 503, 0, + 0, 4503, 4501, 1, 0, 0, 0, 4503, 4502, 1, 0, 0, 0, 4504, 4506, 1, 0, 0, + 0, 4505, 4500, 1, 0, 0, 0, 4505, 4506, 1, 0, 0, 0, 4506, 4769, 1, 0, 0, + 0, 4507, 4508, 5, 64, 0, 0, 4508, 4514, 5, 374, 0, 0, 4509, 4512, 5, 284, + 0, 0, 4510, 4513, 3, 684, 342, 0, 4511, 4513, 5, 503, 0, 0, 4512, 4510, + 1, 0, 0, 0, 4512, 4511, 1, 0, 0, 0, 4513, 4515, 1, 0, 0, 0, 4514, 4509, + 1, 0, 0, 0, 4514, 4515, 1, 0, 0, 0, 4515, 4769, 1, 0, 0, 0, 4516, 4517, + 5, 64, 0, 0, 4517, 4523, 5, 375, 0, 0, 4518, 4521, 5, 284, 0, 0, 4519, + 4522, 3, 684, 342, 0, 4520, 4522, 5, 503, 0, 0, 4521, 4519, 1, 0, 0, 0, + 4521, 4520, 1, 0, 0, 0, 4522, 4524, 1, 0, 0, 0, 4523, 4518, 1, 0, 0, 0, + 4523, 4524, 1, 0, 0, 0, 4524, 4769, 1, 0, 0, 0, 4525, 4526, 5, 64, 0, 0, + 4526, 4532, 5, 142, 0, 0, 4527, 4530, 5, 284, 0, 0, 4528, 4531, 3, 684, + 342, 0, 4529, 4531, 5, 503, 0, 0, 4530, 4528, 1, 0, 0, 0, 4530, 4529, 1, + 0, 0, 0, 4531, 4533, 1, 0, 0, 0, 4532, 4527, 1, 0, 0, 0, 4532, 4533, 1, + 0, 0, 0, 4533, 4769, 1, 0, 0, 0, 4534, 4535, 5, 64, 0, 0, 4535, 4541, 5, + 144, 0, 0, 4536, 4539, 5, 284, 0, 0, 4537, 4540, 3, 684, 342, 0, 4538, + 4540, 5, 503, 0, 0, 4539, 4537, 1, 0, 0, 0, 4539, 4538, 1, 0, 0, 0, 4540, + 4542, 1, 0, 0, 0, 4541, 4536, 1, 0, 0, 0, 4541, 4542, 1, 0, 0, 0, 4542, + 4769, 1, 0, 0, 0, 4543, 4544, 5, 64, 0, 0, 4544, 4545, 5, 113, 0, 0, 4545, + 4551, 5, 115, 0, 0, 4546, 4549, 5, 284, 0, 0, 4547, 4550, 3, 684, 342, + 0, 4548, 4550, 5, 503, 0, 0, 4549, 4547, 1, 0, 0, 0, 4549, 4548, 1, 0, + 0, 0, 4550, 4552, 1, 0, 0, 0, 4551, 4546, 1, 0, 0, 0, 4551, 4552, 1, 0, + 0, 0, 4552, 4769, 1, 0, 0, 0, 4553, 4554, 5, 64, 0, 0, 4554, 4555, 5, 23, + 0, 0, 4555, 4769, 3, 684, 342, 0, 4556, 4557, 5, 64, 0, 0, 4557, 4558, + 5, 27, 0, 0, 4558, 4769, 3, 684, 342, 0, 4559, 4560, 5, 64, 0, 0, 4560, + 4561, 5, 33, 0, 0, 4561, 4769, 3, 684, 342, 0, 4562, 4563, 5, 64, 0, 0, + 4563, 4769, 5, 376, 0, 0, 4564, 4565, 5, 64, 0, 0, 4565, 4769, 5, 325, + 0, 0, 4566, 4567, 5, 64, 0, 0, 4567, 4769, 5, 326, 0, 0, 4568, 4569, 5, + 64, 0, 0, 4569, 4570, 5, 395, 0, 0, 4570, 4769, 5, 325, 0, 0, 4571, 4572, + 5, 64, 0, 0, 4572, 4573, 5, 395, 0, 0, 4573, 4769, 5, 356, 0, 0, 4574, + 4575, 5, 64, 0, 0, 4575, 4576, 5, 398, 0, 0, 4576, 4577, 5, 412, 0, 0, + 4577, 4579, 3, 684, 342, 0, 4578, 4580, 5, 401, 0, 0, 4579, 4578, 1, 0, + 0, 0, 4579, 4580, 1, 0, 0, 0, 4580, 4769, 1, 0, 0, 0, 4581, 4582, 5, 64, + 0, 0, 4582, 4583, 5, 399, 0, 0, 4583, 4584, 5, 412, 0, 0, 4584, 4586, 3, + 684, 342, 0, 4585, 4587, 5, 401, 0, 0, 4586, 4585, 1, 0, 0, 0, 4586, 4587, + 1, 0, 0, 0, 4587, 4769, 1, 0, 0, 0, 4588, 4589, 5, 64, 0, 0, 4589, 4590, + 5, 400, 0, 0, 4590, 4591, 5, 411, 0, 0, 4591, 4769, 3, 684, 342, 0, 4592, + 4593, 5, 64, 0, 0, 4593, 4594, 5, 402, 0, 0, 4594, 4595, 5, 412, 0, 0, + 4595, 4769, 3, 684, 342, 0, 4596, 4597, 5, 64, 0, 0, 4597, 4598, 5, 217, + 0, 0, 4598, 4599, 5, 412, 0, 0, 4599, 4602, 3, 684, 342, 0, 4600, 4601, + 5, 403, 0, 0, 4601, 4603, 5, 501, 0, 0, 4602, 4600, 1, 0, 0, 0, 4602, 4603, + 1, 0, 0, 0, 4603, 4769, 1, 0, 0, 0, 4604, 4605, 5, 64, 0, 0, 4605, 4607, + 5, 185, 0, 0, 4606, 4608, 3, 542, 271, 0, 4607, 4606, 1, 0, 0, 0, 4607, + 4608, 1, 0, 0, 0, 4608, 4769, 1, 0, 0, 0, 4609, 4610, 5, 64, 0, 0, 4610, + 4611, 5, 58, 0, 0, 4611, 4769, 5, 430, 0, 0, 4612, 4613, 5, 64, 0, 0, 4613, + 4614, 5, 29, 0, 0, 4614, 4620, 5, 432, 0, 0, 4615, 4618, 5, 284, 0, 0, + 4616, 4619, 3, 684, 342, 0, 4617, 4619, 5, 503, 0, 0, 4618, 4616, 1, 0, + 0, 0, 4618, 4617, 1, 0, 0, 0, 4619, 4621, 1, 0, 0, 0, 4620, 4615, 1, 0, + 0, 0, 4620, 4621, 1, 0, 0, 0, 4621, 4769, 1, 0, 0, 0, 4622, 4623, 5, 64, + 0, 0, 4623, 4624, 5, 443, 0, 0, 4624, 4769, 5, 432, 0, 0, 4625, 4626, 5, + 64, 0, 0, 4626, 4627, 5, 438, 0, 0, 4627, 4769, 5, 468, 0, 0, 4628, 4629, + 5, 64, 0, 0, 4629, 4630, 5, 441, 0, 0, 4630, 4631, 5, 92, 0, 0, 4631, 4769, + 3, 684, 342, 0, 4632, 4633, 5, 64, 0, 0, 4633, 4634, 5, 441, 0, 0, 4634, + 4635, 5, 92, 0, 0, 4635, 4636, 5, 30, 0, 0, 4636, 4769, 3, 684, 342, 0, + 4637, 4638, 5, 64, 0, 0, 4638, 4639, 5, 441, 0, 0, 4639, 4640, 5, 92, 0, + 0, 4640, 4641, 5, 33, 0, 0, 4641, 4769, 3, 684, 342, 0, 4642, 4643, 5, + 64, 0, 0, 4643, 4644, 5, 441, 0, 0, 4644, 4645, 5, 92, 0, 0, 4645, 4646, + 5, 32, 0, 0, 4646, 4769, 3, 684, 342, 0, 4647, 4648, 5, 64, 0, 0, 4648, + 4649, 5, 430, 0, 0, 4649, 4655, 5, 439, 0, 0, 4650, 4653, 5, 284, 0, 0, + 4651, 4654, 3, 684, 342, 0, 4652, 4654, 5, 503, 0, 0, 4653, 4651, 1, 0, + 0, 0, 4653, 4652, 1, 0, 0, 0, 4654, 4656, 1, 0, 0, 0, 4655, 4650, 1, 0, + 0, 0, 4655, 4656, 1, 0, 0, 0, 4656, 4769, 1, 0, 0, 0, 4657, 4658, 5, 64, + 0, 0, 4658, 4659, 5, 309, 0, 0, 4659, 4665, 5, 333, 0, 0, 4660, 4663, 5, + 284, 0, 0, 4661, 4664, 3, 684, 342, 0, 4662, 4664, 5, 503, 0, 0, 4663, + 4661, 1, 0, 0, 0, 4663, 4662, 1, 0, 0, 0, 4664, 4666, 1, 0, 0, 0, 4665, + 4660, 1, 0, 0, 0, 4665, 4666, 1, 0, 0, 0, 4666, 4769, 1, 0, 0, 0, 4667, + 4668, 5, 64, 0, 0, 4668, 4669, 5, 309, 0, 0, 4669, 4675, 5, 308, 0, 0, + 4670, 4673, 5, 284, 0, 0, 4671, 4674, 3, 684, 342, 0, 4672, 4674, 5, 503, + 0, 0, 4673, 4671, 1, 0, 0, 0, 4673, 4672, 1, 0, 0, 0, 4674, 4676, 1, 0, + 0, 0, 4675, 4670, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676, 4769, 1, 0, + 0, 0, 4677, 4678, 5, 64, 0, 0, 4678, 4679, 5, 26, 0, 0, 4679, 4685, 5, + 369, 0, 0, 4680, 4683, 5, 284, 0, 0, 4681, 4684, 3, 684, 342, 0, 4682, + 4684, 5, 503, 0, 0, 4683, 4681, 1, 0, 0, 0, 4683, 4682, 1, 0, 0, 0, 4684, + 4686, 1, 0, 0, 0, 4685, 4680, 1, 0, 0, 0, 4685, 4686, 1, 0, 0, 0, 4686, + 4769, 1, 0, 0, 0, 4687, 4688, 5, 64, 0, 0, 4688, 4769, 5, 362, 0, 0, 4689, + 4690, 5, 64, 0, 0, 4690, 4691, 5, 362, 0, 0, 4691, 4694, 5, 363, 0, 0, + 4692, 4695, 3, 684, 342, 0, 4693, 4695, 5, 503, 0, 0, 4694, 4692, 1, 0, + 0, 0, 4694, 4693, 1, 0, 0, 0, 4694, 4695, 1, 0, 0, 0, 4695, 4769, 1, 0, + 0, 0, 4696, 4697, 5, 64, 0, 0, 4697, 4698, 5, 362, 0, 0, 4698, 4769, 5, + 364, 0, 0, 4699, 4700, 5, 64, 0, 0, 4700, 4701, 5, 206, 0, 0, 4701, 4704, + 5, 207, 0, 0, 4702, 4703, 5, 414, 0, 0, 4703, 4705, 3, 544, 272, 0, 4704, + 4702, 1, 0, 0, 0, 4704, 4705, 1, 0, 0, 0, 4705, 4769, 1, 0, 0, 0, 4706, + 4707, 5, 64, 0, 0, 4707, 4710, 5, 404, 0, 0, 4708, 4709, 5, 403, 0, 0, + 4709, 4711, 5, 501, 0, 0, 4710, 4708, 1, 0, 0, 0, 4710, 4711, 1, 0, 0, + 0, 4711, 4717, 1, 0, 0, 0, 4712, 4715, 5, 284, 0, 0, 4713, 4716, 3, 684, + 342, 0, 4714, 4716, 5, 503, 0, 0, 4715, 4713, 1, 0, 0, 0, 4715, 4714, 1, + 0, 0, 0, 4716, 4718, 1, 0, 0, 0, 4717, 4712, 1, 0, 0, 0, 4717, 4718, 1, + 0, 0, 0, 4718, 4720, 1, 0, 0, 0, 4719, 4721, 5, 84, 0, 0, 4720, 4719, 1, + 0, 0, 0, 4720, 4721, 1, 0, 0, 0, 4721, 4769, 1, 0, 0, 0, 4722, 4723, 5, + 64, 0, 0, 4723, 4724, 5, 425, 0, 0, 4724, 4725, 5, 426, 0, 0, 4725, 4731, + 5, 308, 0, 0, 4726, 4729, 5, 284, 0, 0, 4727, 4730, 3, 684, 342, 0, 4728, + 4730, 5, 503, 0, 0, 4729, 4727, 1, 0, 0, 0, 4729, 4728, 1, 0, 0, 0, 4730, + 4732, 1, 0, 0, 0, 4731, 4726, 1, 0, 0, 0, 4731, 4732, 1, 0, 0, 0, 4732, + 4769, 1, 0, 0, 0, 4733, 4734, 5, 64, 0, 0, 4734, 4735, 5, 425, 0, 0, 4735, + 4736, 5, 426, 0, 0, 4736, 4742, 5, 333, 0, 0, 4737, 4740, 5, 284, 0, 0, + 4738, 4741, 3, 684, 342, 0, 4739, 4741, 5, 503, 0, 0, 4740, 4738, 1, 0, + 0, 0, 4740, 4739, 1, 0, 0, 0, 4741, 4743, 1, 0, 0, 0, 4742, 4737, 1, 0, + 0, 0, 4742, 4743, 1, 0, 0, 0, 4743, 4769, 1, 0, 0, 0, 4744, 4745, 5, 64, + 0, 0, 4745, 4746, 5, 425, 0, 0, 4746, 4752, 5, 118, 0, 0, 4747, 4750, 5, + 284, 0, 0, 4748, 4751, 3, 684, 342, 0, 4749, 4751, 5, 503, 0, 0, 4750, + 4748, 1, 0, 0, 0, 4750, 4749, 1, 0, 0, 0, 4751, 4753, 1, 0, 0, 0, 4752, + 4747, 1, 0, 0, 0, 4752, 4753, 1, 0, 0, 0, 4753, 4769, 1, 0, 0, 0, 4754, + 4755, 5, 64, 0, 0, 4755, 4769, 5, 428, 0, 0, 4756, 4757, 5, 64, 0, 0, 4757, + 4769, 5, 379, 0, 0, 4758, 4759, 5, 64, 0, 0, 4759, 4760, 5, 344, 0, 0, + 4760, 4766, 5, 376, 0, 0, 4761, 4764, 5, 284, 0, 0, 4762, 4765, 3, 684, + 342, 0, 4763, 4765, 5, 503, 0, 0, 4764, 4762, 1, 0, 0, 0, 4764, 4763, 1, + 0, 0, 0, 4765, 4767, 1, 0, 0, 0, 4766, 4761, 1, 0, 0, 0, 4766, 4767, 1, + 0, 0, 0, 4767, 4769, 1, 0, 0, 0, 4768, 4442, 1, 0, 0, 0, 4768, 4444, 1, + 0, 0, 0, 4768, 4453, 1, 0, 0, 0, 4768, 4462, 1, 0, 0, 0, 4768, 4471, 1, + 0, 0, 0, 4768, 4480, 1, 0, 0, 0, 4768, 4489, 1, 0, 0, 0, 4768, 4498, 1, + 0, 0, 0, 4768, 4507, 1, 0, 0, 0, 4768, 4516, 1, 0, 0, 0, 4768, 4525, 1, + 0, 0, 0, 4768, 4534, 1, 0, 0, 0, 4768, 4543, 1, 0, 0, 0, 4768, 4553, 1, + 0, 0, 0, 4768, 4556, 1, 0, 0, 0, 4768, 4559, 1, 0, 0, 0, 4768, 4562, 1, + 0, 0, 0, 4768, 4564, 1, 0, 0, 0, 4768, 4566, 1, 0, 0, 0, 4768, 4568, 1, + 0, 0, 0, 4768, 4571, 1, 0, 0, 0, 4768, 4574, 1, 0, 0, 0, 4768, 4581, 1, + 0, 0, 0, 4768, 4588, 1, 0, 0, 0, 4768, 4592, 1, 0, 0, 0, 4768, 4596, 1, + 0, 0, 0, 4768, 4604, 1, 0, 0, 0, 4768, 4609, 1, 0, 0, 0, 4768, 4612, 1, + 0, 0, 0, 4768, 4622, 1, 0, 0, 0, 4768, 4625, 1, 0, 0, 0, 4768, 4628, 1, + 0, 0, 0, 4768, 4632, 1, 0, 0, 0, 4768, 4637, 1, 0, 0, 0, 4768, 4642, 1, + 0, 0, 0, 4768, 4647, 1, 0, 0, 0, 4768, 4657, 1, 0, 0, 0, 4768, 4667, 1, + 0, 0, 0, 4768, 4677, 1, 0, 0, 0, 4768, 4687, 1, 0, 0, 0, 4768, 4689, 1, + 0, 0, 0, 4768, 4696, 1, 0, 0, 0, 4768, 4699, 1, 0, 0, 0, 4768, 4706, 1, + 0, 0, 0, 4768, 4722, 1, 0, 0, 0, 4768, 4733, 1, 0, 0, 0, 4768, 4744, 1, + 0, 0, 0, 4768, 4754, 1, 0, 0, 0, 4768, 4756, 1, 0, 0, 0, 4768, 4758, 1, + 0, 0, 0, 4769, 541, 1, 0, 0, 0, 4770, 4771, 5, 71, 0, 0, 4771, 4776, 3, + 546, 273, 0, 4772, 4773, 5, 280, 0, 0, 4773, 4775, 3, 546, 273, 0, 4774, + 4772, 1, 0, 0, 0, 4775, 4778, 1, 0, 0, 0, 4776, 4774, 1, 0, 0, 0, 4776, + 4777, 1, 0, 0, 0, 4777, 4784, 1, 0, 0, 0, 4778, 4776, 1, 0, 0, 0, 4779, + 4782, 5, 284, 0, 0, 4780, 4783, 3, 684, 342, 0, 4781, 4783, 5, 503, 0, + 0, 4782, 4780, 1, 0, 0, 0, 4782, 4781, 1, 0, 0, 0, 4783, 4785, 1, 0, 0, + 0, 4784, 4779, 1, 0, 0, 0, 4784, 4785, 1, 0, 0, 0, 4785, 4792, 1, 0, 0, + 0, 4786, 4789, 5, 284, 0, 0, 4787, 4790, 3, 684, 342, 0, 4788, 4790, 5, + 503, 0, 0, 4789, 4787, 1, 0, 0, 0, 4789, 4788, 1, 0, 0, 0, 4790, 4792, + 1, 0, 0, 0, 4791, 4770, 1, 0, 0, 0, 4791, 4786, 1, 0, 0, 0, 4792, 543, + 1, 0, 0, 0, 4793, 4794, 7, 31, 0, 0, 4794, 545, 1, 0, 0, 0, 4795, 4796, + 5, 423, 0, 0, 4796, 4797, 7, 32, 0, 0, 4797, 4802, 5, 499, 0, 0, 4798, + 4799, 5, 503, 0, 0, 4799, 4800, 7, 32, 0, 0, 4800, 4802, 5, 499, 0, 0, + 4801, 4795, 1, 0, 0, 0, 4801, 4798, 1, 0, 0, 0, 4802, 547, 1, 0, 0, 0, + 4803, 4804, 5, 499, 0, 0, 4804, 4805, 5, 472, 0, 0, 4805, 4806, 3, 550, + 275, 0, 4806, 549, 1, 0, 0, 0, 4807, 4812, 5, 499, 0, 0, 4808, 4812, 5, + 501, 0, 0, 4809, 4812, 3, 692, 346, 0, 4810, 4812, 5, 283, 0, 0, 4811, + 4807, 1, 0, 0, 0, 4811, 4808, 1, 0, 0, 0, 4811, 4809, 1, 0, 0, 0, 4811, + 4810, 1, 0, 0, 0, 4812, 551, 1, 0, 0, 0, 4813, 4814, 5, 65, 0, 0, 4814, + 4815, 5, 23, 0, 0, 4815, 4928, 3, 684, 342, 0, 4816, 4817, 5, 65, 0, 0, + 4817, 4818, 5, 27, 0, 0, 4818, 4928, 3, 684, 342, 0, 4819, 4820, 5, 65, + 0, 0, 4820, 4821, 5, 30, 0, 0, 4821, 4928, 3, 684, 342, 0, 4822, 4823, + 5, 65, 0, 0, 4823, 4824, 5, 31, 0, 0, 4824, 4928, 3, 684, 342, 0, 4825, + 4826, 5, 65, 0, 0, 4826, 4827, 5, 32, 0, 0, 4827, 4928, 3, 684, 342, 0, + 4828, 4829, 5, 65, 0, 0, 4829, 4830, 5, 33, 0, 0, 4830, 4928, 3, 684, 342, + 0, 4831, 4832, 5, 65, 0, 0, 4832, 4833, 5, 34, 0, 0, 4833, 4928, 3, 684, + 342, 0, 4834, 4835, 5, 65, 0, 0, 4835, 4836, 5, 35, 0, 0, 4836, 4928, 3, + 684, 342, 0, 4837, 4838, 5, 65, 0, 0, 4838, 4839, 5, 28, 0, 0, 4839, 4928, + 3, 684, 342, 0, 4840, 4841, 5, 65, 0, 0, 4841, 4842, 5, 37, 0, 0, 4842, + 4928, 3, 684, 342, 0, 4843, 4844, 5, 65, 0, 0, 4844, 4845, 5, 113, 0, 0, + 4845, 4846, 5, 114, 0, 0, 4846, 4928, 3, 684, 342, 0, 4847, 4848, 5, 65, + 0, 0, 4848, 4849, 5, 29, 0, 0, 4849, 4852, 5, 503, 0, 0, 4850, 4851, 5, + 137, 0, 0, 4851, 4853, 5, 84, 0, 0, 4852, 4850, 1, 0, 0, 0, 4852, 4853, + 1, 0, 0, 0, 4853, 4928, 1, 0, 0, 0, 4854, 4855, 5, 65, 0, 0, 4855, 4856, + 5, 29, 0, 0, 4856, 4857, 5, 431, 0, 0, 4857, 4928, 3, 684, 342, 0, 4858, + 4859, 5, 65, 0, 0, 4859, 4860, 5, 443, 0, 0, 4860, 4861, 5, 431, 0, 0, + 4861, 4928, 5, 499, 0, 0, 4862, 4863, 5, 65, 0, 0, 4863, 4864, 5, 438, + 0, 0, 4864, 4865, 5, 443, 0, 0, 4865, 4928, 5, 499, 0, 0, 4866, 4867, 5, + 65, 0, 0, 4867, 4868, 5, 309, 0, 0, 4868, 4869, 5, 332, 0, 0, 4869, 4928, + 3, 684, 342, 0, 4870, 4871, 5, 65, 0, 0, 4871, 4872, 5, 309, 0, 0, 4872, + 4873, 5, 307, 0, 0, 4873, 4928, 3, 684, 342, 0, 4874, 4875, 5, 65, 0, 0, + 4875, 4876, 5, 26, 0, 0, 4876, 4877, 5, 23, 0, 0, 4877, 4928, 3, 684, 342, + 0, 4878, 4879, 5, 65, 0, 0, 4879, 4882, 5, 362, 0, 0, 4880, 4883, 3, 684, + 342, 0, 4881, 4883, 5, 503, 0, 0, 4882, 4880, 1, 0, 0, 0, 4882, 4881, 1, + 0, 0, 0, 4882, 4883, 1, 0, 0, 0, 4883, 4928, 1, 0, 0, 0, 4884, 4885, 5, + 65, 0, 0, 4885, 4886, 5, 209, 0, 0, 4886, 4887, 5, 92, 0, 0, 4887, 4888, + 7, 1, 0, 0, 4888, 4891, 3, 684, 342, 0, 4889, 4890, 5, 184, 0, 0, 4890, + 4892, 5, 503, 0, 0, 4891, 4889, 1, 0, 0, 0, 4891, 4892, 1, 0, 0, 0, 4892, + 4928, 1, 0, 0, 0, 4893, 4894, 5, 65, 0, 0, 4894, 4895, 5, 395, 0, 0, 4895, + 4896, 5, 484, 0, 0, 4896, 4928, 3, 558, 279, 0, 4897, 4898, 5, 65, 0, 0, + 4898, 4899, 5, 425, 0, 0, 4899, 4900, 5, 426, 0, 0, 4900, 4901, 5, 307, + 0, 0, 4901, 4928, 3, 684, 342, 0, 4902, 4903, 5, 65, 0, 0, 4903, 4904, + 5, 344, 0, 0, 4904, 4905, 5, 343, 0, 0, 4905, 4928, 3, 684, 342, 0, 4906, + 4907, 5, 65, 0, 0, 4907, 4928, 5, 428, 0, 0, 4908, 4909, 5, 65, 0, 0, 4909, + 4910, 5, 378, 0, 0, 4910, 4911, 5, 70, 0, 0, 4911, 4912, 5, 33, 0, 0, 4912, + 4913, 3, 684, 342, 0, 4913, 4914, 5, 184, 0, 0, 4914, 4915, 3, 686, 343, + 0, 4915, 4928, 1, 0, 0, 0, 4916, 4917, 5, 65, 0, 0, 4917, 4918, 5, 378, + 0, 0, 4918, 4919, 5, 70, 0, 0, 4919, 4920, 5, 34, 0, 0, 4920, 4921, 3, + 684, 342, 0, 4921, 4922, 5, 184, 0, 0, 4922, 4923, 3, 686, 343, 0, 4923, + 4928, 1, 0, 0, 0, 4924, 4925, 5, 65, 0, 0, 4925, 4926, 5, 378, 0, 0, 4926, + 4928, 3, 686, 343, 0, 4927, 4813, 1, 0, 0, 0, 4927, 4816, 1, 0, 0, 0, 4927, + 4819, 1, 0, 0, 0, 4927, 4822, 1, 0, 0, 0, 4927, 4825, 1, 0, 0, 0, 4927, + 4828, 1, 0, 0, 0, 4927, 4831, 1, 0, 0, 0, 4927, 4834, 1, 0, 0, 0, 4927, + 4837, 1, 0, 0, 0, 4927, 4840, 1, 0, 0, 0, 4927, 4843, 1, 0, 0, 0, 4927, + 4847, 1, 0, 0, 0, 4927, 4854, 1, 0, 0, 0, 4927, 4858, 1, 0, 0, 0, 4927, + 4862, 1, 0, 0, 0, 4927, 4866, 1, 0, 0, 0, 4927, 4870, 1, 0, 0, 0, 4927, + 4874, 1, 0, 0, 0, 4927, 4878, 1, 0, 0, 0, 4927, 4884, 1, 0, 0, 0, 4927, + 4893, 1, 0, 0, 0, 4927, 4897, 1, 0, 0, 0, 4927, 4902, 1, 0, 0, 0, 4927, + 4906, 1, 0, 0, 0, 4927, 4908, 1, 0, 0, 0, 4927, 4916, 1, 0, 0, 0, 4927, + 4924, 1, 0, 0, 0, 4928, 553, 1, 0, 0, 0, 4929, 4931, 5, 69, 0, 0, 4930, + 4932, 7, 33, 0, 0, 4931, 4930, 1, 0, 0, 0, 4931, 4932, 1, 0, 0, 0, 4932, + 4933, 1, 0, 0, 0, 4933, 4934, 3, 566, 283, 0, 4934, 4935, 5, 70, 0, 0, + 4935, 4936, 5, 395, 0, 0, 4936, 4937, 5, 484, 0, 0, 4937, 4942, 3, 558, + 279, 0, 4938, 4940, 5, 75, 0, 0, 4939, 4938, 1, 0, 0, 0, 4939, 4940, 1, + 0, 0, 0, 4940, 4941, 1, 0, 0, 0, 4941, 4943, 5, 503, 0, 0, 4942, 4939, + 1, 0, 0, 0, 4942, 4943, 1, 0, 0, 0, 4943, 4947, 1, 0, 0, 0, 4944, 4946, + 3, 556, 278, 0, 4945, 4944, 1, 0, 0, 0, 4946, 4949, 1, 0, 0, 0, 4947, 4945, + 1, 0, 0, 0, 4947, 4948, 1, 0, 0, 0, 4948, 4952, 1, 0, 0, 0, 4949, 4947, + 1, 0, 0, 0, 4950, 4951, 5, 71, 0, 0, 4951, 4953, 3, 646, 323, 0, 4952, + 4950, 1, 0, 0, 0, 4952, 4953, 1, 0, 0, 0, 4953, 4960, 1, 0, 0, 0, 4954, + 4955, 5, 8, 0, 0, 4955, 4958, 3, 594, 297, 0, 4956, 4957, 5, 72, 0, 0, + 4957, 4959, 3, 646, 323, 0, 4958, 4956, 1, 0, 0, 0, 4958, 4959, 1, 0, 0, + 0, 4959, 4961, 1, 0, 0, 0, 4960, 4954, 1, 0, 0, 0, 4960, 4961, 1, 0, 0, + 0, 4961, 4964, 1, 0, 0, 0, 4962, 4963, 5, 9, 0, 0, 4963, 4965, 3, 590, + 295, 0, 4964, 4962, 1, 0, 0, 0, 4964, 4965, 1, 0, 0, 0, 4965, 4968, 1, + 0, 0, 0, 4966, 4967, 5, 74, 0, 0, 4967, 4969, 5, 501, 0, 0, 4968, 4966, + 1, 0, 0, 0, 4968, 4969, 1, 0, 0, 0, 4969, 4972, 1, 0, 0, 0, 4970, 4971, + 5, 73, 0, 0, 4971, 4973, 5, 501, 0, 0, 4972, 4970, 1, 0, 0, 0, 4972, 4973, + 1, 0, 0, 0, 4973, 555, 1, 0, 0, 0, 4974, 4976, 3, 580, 290, 0, 4975, 4974, + 1, 0, 0, 0, 4975, 4976, 1, 0, 0, 0, 4976, 4977, 1, 0, 0, 0, 4977, 4978, + 5, 85, 0, 0, 4978, 4979, 5, 395, 0, 0, 4979, 4980, 5, 484, 0, 0, 4980, + 4985, 3, 558, 279, 0, 4981, 4983, 5, 75, 0, 0, 4982, 4981, 1, 0, 0, 0, + 4982, 4983, 1, 0, 0, 0, 4983, 4984, 1, 0, 0, 0, 4984, 4986, 5, 503, 0, + 0, 4985, 4982, 1, 0, 0, 0, 4985, 4986, 1, 0, 0, 0, 4986, 4989, 1, 0, 0, + 0, 4987, 4988, 5, 92, 0, 0, 4988, 4990, 3, 646, 323, 0, 4989, 4987, 1, + 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990, 557, 1, 0, 0, 0, 4991, 4992, 7, + 34, 0, 0, 4992, 559, 1, 0, 0, 0, 4993, 5001, 3, 562, 281, 0, 4994, 4996, + 5, 123, 0, 0, 4995, 4997, 5, 84, 0, 0, 4996, 4995, 1, 0, 0, 0, 4996, 4997, + 1, 0, 0, 0, 4997, 4998, 1, 0, 0, 0, 4998, 5000, 3, 562, 281, 0, 4999, 4994, + 1, 0, 0, 0, 5000, 5003, 1, 0, 0, 0, 5001, 4999, 1, 0, 0, 0, 5001, 5002, + 1, 0, 0, 0, 5002, 561, 1, 0, 0, 0, 5003, 5001, 1, 0, 0, 0, 5004, 5006, + 3, 564, 282, 0, 5005, 5007, 3, 572, 286, 0, 5006, 5005, 1, 0, 0, 0, 5006, + 5007, 1, 0, 0, 0, 5007, 5009, 1, 0, 0, 0, 5008, 5010, 3, 582, 291, 0, 5009, + 5008, 1, 0, 0, 0, 5009, 5010, 1, 0, 0, 0, 5010, 5012, 1, 0, 0, 0, 5011, + 5013, 3, 584, 292, 0, 5012, 5011, 1, 0, 0, 0, 5012, 5013, 1, 0, 0, 0, 5013, + 5015, 1, 0, 0, 0, 5014, 5016, 3, 586, 293, 0, 5015, 5014, 1, 0, 0, 0, 5015, + 5016, 1, 0, 0, 0, 5016, 5018, 1, 0, 0, 0, 5017, 5019, 3, 588, 294, 0, 5018, + 5017, 1, 0, 0, 0, 5018, 5019, 1, 0, 0, 0, 5019, 5021, 1, 0, 0, 0, 5020, + 5022, 3, 596, 298, 0, 5021, 5020, 1, 0, 0, 0, 5021, 5022, 1, 0, 0, 0, 5022, + 5041, 1, 0, 0, 0, 5023, 5025, 3, 572, 286, 0, 5024, 5026, 3, 582, 291, + 0, 5025, 5024, 1, 0, 0, 0, 5025, 5026, 1, 0, 0, 0, 5026, 5028, 1, 0, 0, + 0, 5027, 5029, 3, 584, 292, 0, 5028, 5027, 1, 0, 0, 0, 5028, 5029, 1, 0, + 0, 0, 5029, 5031, 1, 0, 0, 0, 5030, 5032, 3, 586, 293, 0, 5031, 5030, 1, + 0, 0, 0, 5031, 5032, 1, 0, 0, 0, 5032, 5033, 1, 0, 0, 0, 5033, 5035, 3, + 564, 282, 0, 5034, 5036, 3, 588, 294, 0, 5035, 5034, 1, 0, 0, 0, 5035, + 5036, 1, 0, 0, 0, 5036, 5038, 1, 0, 0, 0, 5037, 5039, 3, 596, 298, 0, 5038, + 5037, 1, 0, 0, 0, 5038, 5039, 1, 0, 0, 0, 5039, 5041, 1, 0, 0, 0, 5040, + 5004, 1, 0, 0, 0, 5040, 5023, 1, 0, 0, 0, 5041, 563, 1, 0, 0, 0, 5042, + 5044, 5, 69, 0, 0, 5043, 5045, 7, 33, 0, 0, 5044, 5043, 1, 0, 0, 0, 5044, + 5045, 1, 0, 0, 0, 5045, 5046, 1, 0, 0, 0, 5046, 5047, 3, 566, 283, 0, 5047, + 565, 1, 0, 0, 0, 5048, 5058, 5, 477, 0, 0, 5049, 5054, 3, 568, 284, 0, + 5050, 5051, 5, 483, 0, 0, 5051, 5053, 3, 568, 284, 0, 5052, 5050, 1, 0, + 0, 0, 5053, 5056, 1, 0, 0, 0, 5054, 5052, 1, 0, 0, 0, 5054, 5055, 1, 0, + 0, 0, 5055, 5058, 1, 0, 0, 0, 5056, 5054, 1, 0, 0, 0, 5057, 5048, 1, 0, + 0, 0, 5057, 5049, 1, 0, 0, 0, 5058, 567, 1, 0, 0, 0, 5059, 5062, 3, 646, + 323, 0, 5060, 5061, 5, 75, 0, 0, 5061, 5063, 3, 570, 285, 0, 5062, 5060, + 1, 0, 0, 0, 5062, 5063, 1, 0, 0, 0, 5063, 5070, 1, 0, 0, 0, 5064, 5067, + 3, 672, 336, 0, 5065, 5066, 5, 75, 0, 0, 5066, 5068, 3, 570, 285, 0, 5067, + 5065, 1, 0, 0, 0, 5067, 5068, 1, 0, 0, 0, 5068, 5070, 1, 0, 0, 0, 5069, + 5059, 1, 0, 0, 0, 5069, 5064, 1, 0, 0, 0, 5070, 569, 1, 0, 0, 0, 5071, + 5074, 5, 503, 0, 0, 5072, 5074, 3, 706, 353, 0, 5073, 5071, 1, 0, 0, 0, + 5073, 5072, 1, 0, 0, 0, 5074, 571, 1, 0, 0, 0, 5075, 5076, 5, 70, 0, 0, + 5076, 5080, 3, 574, 287, 0, 5077, 5079, 3, 576, 288, 0, 5078, 5077, 1, + 0, 0, 0, 5079, 5082, 1, 0, 0, 0, 5080, 5078, 1, 0, 0, 0, 5080, 5081, 1, + 0, 0, 0, 5081, 573, 1, 0, 0, 0, 5082, 5080, 1, 0, 0, 0, 5083, 5088, 3, + 684, 342, 0, 5084, 5086, 5, 75, 0, 0, 5085, 5084, 1, 0, 0, 0, 5085, 5086, + 1, 0, 0, 0, 5086, 5087, 1, 0, 0, 0, 5087, 5089, 5, 503, 0, 0, 5088, 5085, + 1, 0, 0, 0, 5088, 5089, 1, 0, 0, 0, 5089, 5100, 1, 0, 0, 0, 5090, 5091, + 5, 485, 0, 0, 5091, 5092, 3, 560, 280, 0, 5092, 5097, 5, 486, 0, 0, 5093, + 5095, 5, 75, 0, 0, 5094, 5093, 1, 0, 0, 0, 5094, 5095, 1, 0, 0, 0, 5095, + 5096, 1, 0, 0, 0, 5096, 5098, 5, 503, 0, 0, 5097, 5094, 1, 0, 0, 0, 5097, + 5098, 1, 0, 0, 0, 5098, 5100, 1, 0, 0, 0, 5099, 5083, 1, 0, 0, 0, 5099, + 5090, 1, 0, 0, 0, 5100, 575, 1, 0, 0, 0, 5101, 5103, 3, 580, 290, 0, 5102, + 5101, 1, 0, 0, 0, 5102, 5103, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, + 5105, 5, 85, 0, 0, 5105, 5108, 3, 574, 287, 0, 5106, 5107, 5, 92, 0, 0, + 5107, 5109, 3, 646, 323, 0, 5108, 5106, 1, 0, 0, 0, 5108, 5109, 1, 0, 0, + 0, 5109, 5122, 1, 0, 0, 0, 5110, 5112, 3, 580, 290, 0, 5111, 5110, 1, 0, + 0, 0, 5111, 5112, 1, 0, 0, 0, 5112, 5113, 1, 0, 0, 0, 5113, 5114, 5, 85, + 0, 0, 5114, 5119, 3, 578, 289, 0, 5115, 5117, 5, 75, 0, 0, 5116, 5115, + 1, 0, 0, 0, 5116, 5117, 1, 0, 0, 0, 5117, 5118, 1, 0, 0, 0, 5118, 5120, + 5, 503, 0, 0, 5119, 5116, 1, 0, 0, 0, 5119, 5120, 1, 0, 0, 0, 5120, 5122, + 1, 0, 0, 0, 5121, 5102, 1, 0, 0, 0, 5121, 5111, 1, 0, 0, 0, 5122, 577, + 1, 0, 0, 0, 5123, 5124, 5, 503, 0, 0, 5124, 5125, 5, 478, 0, 0, 5125, 5126, + 3, 684, 342, 0, 5126, 5127, 5, 478, 0, 0, 5127, 5128, 3, 684, 342, 0, 5128, + 5134, 1, 0, 0, 0, 5129, 5130, 3, 684, 342, 0, 5130, 5131, 5, 478, 0, 0, + 5131, 5132, 3, 684, 342, 0, 5132, 5134, 1, 0, 0, 0, 5133, 5123, 1, 0, 0, + 0, 5133, 5129, 1, 0, 0, 0, 5134, 579, 1, 0, 0, 0, 5135, 5137, 5, 86, 0, + 0, 5136, 5138, 5, 89, 0, 0, 5137, 5136, 1, 0, 0, 0, 5137, 5138, 1, 0, 0, + 0, 5138, 5150, 1, 0, 0, 0, 5139, 5141, 5, 87, 0, 0, 5140, 5142, 5, 89, + 0, 0, 5141, 5140, 1, 0, 0, 0, 5141, 5142, 1, 0, 0, 0, 5142, 5150, 1, 0, + 0, 0, 5143, 5150, 5, 88, 0, 0, 5144, 5146, 5, 90, 0, 0, 5145, 5147, 5, + 89, 0, 0, 5146, 5145, 1, 0, 0, 0, 5146, 5147, 1, 0, 0, 0, 5147, 5150, 1, + 0, 0, 0, 5148, 5150, 5, 91, 0, 0, 5149, 5135, 1, 0, 0, 0, 5149, 5139, 1, + 0, 0, 0, 5149, 5143, 1, 0, 0, 0, 5149, 5144, 1, 0, 0, 0, 5149, 5148, 1, + 0, 0, 0, 5150, 581, 1, 0, 0, 0, 5151, 5152, 5, 71, 0, 0, 5152, 5153, 3, + 646, 323, 0, 5153, 583, 1, 0, 0, 0, 5154, 5155, 5, 8, 0, 0, 5155, 5156, + 3, 682, 341, 0, 5156, 585, 1, 0, 0, 0, 5157, 5158, 5, 72, 0, 0, 5158, 5159, + 3, 646, 323, 0, 5159, 587, 1, 0, 0, 0, 5160, 5161, 5, 9, 0, 0, 5161, 5162, + 3, 590, 295, 0, 5162, 589, 1, 0, 0, 0, 5163, 5168, 3, 592, 296, 0, 5164, + 5165, 5, 483, 0, 0, 5165, 5167, 3, 592, 296, 0, 5166, 5164, 1, 0, 0, 0, + 5167, 5170, 1, 0, 0, 0, 5168, 5166, 1, 0, 0, 0, 5168, 5169, 1, 0, 0, 0, + 5169, 591, 1, 0, 0, 0, 5170, 5168, 1, 0, 0, 0, 5171, 5173, 3, 646, 323, + 0, 5172, 5174, 7, 6, 0, 0, 5173, 5172, 1, 0, 0, 0, 5173, 5174, 1, 0, 0, + 0, 5174, 593, 1, 0, 0, 0, 5175, 5180, 3, 646, 323, 0, 5176, 5177, 5, 483, + 0, 0, 5177, 5179, 3, 646, 323, 0, 5178, 5176, 1, 0, 0, 0, 5179, 5182, 1, + 0, 0, 0, 5180, 5178, 1, 0, 0, 0, 5180, 5181, 1, 0, 0, 0, 5181, 595, 1, + 0, 0, 0, 5182, 5180, 1, 0, 0, 0, 5183, 5184, 5, 74, 0, 0, 5184, 5187, 5, + 501, 0, 0, 5185, 5186, 5, 73, 0, 0, 5186, 5188, 5, 501, 0, 0, 5187, 5185, + 1, 0, 0, 0, 5187, 5188, 1, 0, 0, 0, 5188, 5196, 1, 0, 0, 0, 5189, 5190, + 5, 73, 0, 0, 5190, 5193, 5, 501, 0, 0, 5191, 5192, 5, 74, 0, 0, 5192, 5194, + 5, 501, 0, 0, 5193, 5191, 1, 0, 0, 0, 5193, 5194, 1, 0, 0, 0, 5194, 5196, + 1, 0, 0, 0, 5195, 5183, 1, 0, 0, 0, 5195, 5189, 1, 0, 0, 0, 5196, 597, + 1, 0, 0, 0, 5197, 5214, 3, 602, 301, 0, 5198, 5214, 3, 604, 302, 0, 5199, + 5214, 3, 606, 303, 0, 5200, 5214, 3, 608, 304, 0, 5201, 5214, 3, 610, 305, + 0, 5202, 5214, 3, 612, 306, 0, 5203, 5214, 3, 614, 307, 0, 5204, 5214, + 3, 616, 308, 0, 5205, 5214, 3, 600, 300, 0, 5206, 5214, 3, 622, 311, 0, + 5207, 5214, 3, 628, 314, 0, 5208, 5214, 3, 630, 315, 0, 5209, 5214, 3, + 644, 322, 0, 5210, 5214, 3, 632, 316, 0, 5211, 5214, 3, 636, 318, 0, 5212, + 5214, 3, 642, 321, 0, 5213, 5197, 1, 0, 0, 0, 5213, 5198, 1, 0, 0, 0, 5213, + 5199, 1, 0, 0, 0, 5213, 5200, 1, 0, 0, 0, 5213, 5201, 1, 0, 0, 0, 5213, + 5202, 1, 0, 0, 0, 5213, 5203, 1, 0, 0, 0, 5213, 5204, 1, 0, 0, 0, 5213, + 5205, 1, 0, 0, 0, 5213, 5206, 1, 0, 0, 0, 5213, 5207, 1, 0, 0, 0, 5213, + 5208, 1, 0, 0, 0, 5213, 5209, 1, 0, 0, 0, 5213, 5210, 1, 0, 0, 0, 5213, + 5211, 1, 0, 0, 0, 5213, 5212, 1, 0, 0, 0, 5214, 599, 1, 0, 0, 0, 5215, + 5216, 5, 156, 0, 0, 5216, 5217, 5, 499, 0, 0, 5217, 601, 1, 0, 0, 0, 5218, + 5219, 5, 55, 0, 0, 5219, 5220, 5, 411, 0, 0, 5220, 5221, 5, 58, 0, 0, 5221, + 5224, 5, 499, 0, 0, 5222, 5223, 5, 60, 0, 0, 5223, 5225, 5, 499, 0, 0, + 5224, 5222, 1, 0, 0, 0, 5224, 5225, 1, 0, 0, 0, 5225, 5226, 1, 0, 0, 0, + 5226, 5227, 5, 61, 0, 0, 5227, 5242, 5, 499, 0, 0, 5228, 5229, 5, 55, 0, + 0, 5229, 5230, 5, 57, 0, 0, 5230, 5242, 5, 499, 0, 0, 5231, 5232, 5, 55, + 0, 0, 5232, 5233, 5, 59, 0, 0, 5233, 5234, 5, 62, 0, 0, 5234, 5235, 5, + 499, 0, 0, 5235, 5236, 5, 63, 0, 0, 5236, 5239, 5, 501, 0, 0, 5237, 5238, + 5, 61, 0, 0, 5238, 5240, 5, 499, 0, 0, 5239, 5237, 1, 0, 0, 0, 5239, 5240, + 1, 0, 0, 0, 5240, 5242, 1, 0, 0, 0, 5241, 5218, 1, 0, 0, 0, 5241, 5228, + 1, 0, 0, 0, 5241, 5231, 1, 0, 0, 0, 5242, 603, 1, 0, 0, 0, 5243, 5244, + 5, 56, 0, 0, 5244, 605, 1, 0, 0, 0, 5245, 5262, 5, 383, 0, 0, 5246, 5247, + 5, 384, 0, 0, 5247, 5249, 5, 395, 0, 0, 5248, 5250, 5, 90, 0, 0, 5249, + 5248, 1, 0, 0, 0, 5249, 5250, 1, 0, 0, 0, 5250, 5252, 1, 0, 0, 0, 5251, + 5253, 5, 190, 0, 0, 5252, 5251, 1, 0, 0, 0, 5252, 5253, 1, 0, 0, 0, 5253, + 5255, 1, 0, 0, 0, 5254, 5256, 5, 396, 0, 0, 5255, 5254, 1, 0, 0, 0, 5255, + 5256, 1, 0, 0, 0, 5256, 5258, 1, 0, 0, 0, 5257, 5259, 5, 397, 0, 0, 5258, + 5257, 1, 0, 0, 0, 5258, 5259, 1, 0, 0, 0, 5259, 5262, 1, 0, 0, 0, 5260, + 5262, 5, 384, 0, 0, 5261, 5245, 1, 0, 0, 0, 5261, 5246, 1, 0, 0, 0, 5261, + 5260, 1, 0, 0, 0, 5262, 607, 1, 0, 0, 0, 5263, 5264, 5, 385, 0, 0, 5264, + 609, 1, 0, 0, 0, 5265, 5266, 5, 386, 0, 0, 5266, 611, 1, 0, 0, 0, 5267, + 5268, 5, 387, 0, 0, 5268, 5269, 5, 388, 0, 0, 5269, 5270, 5, 499, 0, 0, + 5270, 613, 1, 0, 0, 0, 5271, 5272, 5, 387, 0, 0, 5272, 5273, 5, 59, 0, + 0, 5273, 5274, 5, 499, 0, 0, 5274, 615, 1, 0, 0, 0, 5275, 5277, 5, 389, + 0, 0, 5276, 5278, 3, 618, 309, 0, 5277, 5276, 1, 0, 0, 0, 5277, 5278, 1, + 0, 0, 0, 5278, 5281, 1, 0, 0, 0, 5279, 5280, 5, 418, 0, 0, 5280, 5282, + 3, 620, 310, 0, 5281, 5279, 1, 0, 0, 0, 5281, 5282, 1, 0, 0, 0, 5282, 5287, + 1, 0, 0, 0, 5283, 5284, 5, 64, 0, 0, 5284, 5285, 5, 389, 0, 0, 5285, 5287, + 5, 390, 0, 0, 5286, 5275, 1, 0, 0, 0, 5286, 5283, 1, 0, 0, 0, 5287, 617, + 1, 0, 0, 0, 5288, 5289, 3, 684, 342, 0, 5289, 5290, 5, 484, 0, 0, 5290, + 5291, 5, 477, 0, 0, 5291, 5295, 1, 0, 0, 0, 5292, 5295, 3, 684, 342, 0, + 5293, 5295, 5, 477, 0, 0, 5294, 5288, 1, 0, 0, 0, 5294, 5292, 1, 0, 0, + 0, 5294, 5293, 1, 0, 0, 0, 5295, 619, 1, 0, 0, 0, 5296, 5297, 7, 35, 0, + 0, 5297, 621, 1, 0, 0, 0, 5298, 5299, 5, 66, 0, 0, 5299, 5303, 3, 624, + 312, 0, 5300, 5301, 5, 66, 0, 0, 5301, 5303, 5, 84, 0, 0, 5302, 5298, 1, + 0, 0, 0, 5302, 5300, 1, 0, 0, 0, 5303, 623, 1, 0, 0, 0, 5304, 5309, 3, + 626, 313, 0, 5305, 5306, 5, 483, 0, 0, 5306, 5308, 3, 626, 313, 0, 5307, + 5305, 1, 0, 0, 0, 5308, 5311, 1, 0, 0, 0, 5309, 5307, 1, 0, 0, 0, 5309, + 5310, 1, 0, 0, 0, 5310, 625, 1, 0, 0, 0, 5311, 5309, 1, 0, 0, 0, 5312, + 5313, 7, 36, 0, 0, 5313, 627, 1, 0, 0, 0, 5314, 5315, 5, 67, 0, 0, 5315, + 5316, 5, 331, 0, 0, 5316, 629, 1, 0, 0, 0, 5317, 5318, 5, 68, 0, 0, 5318, + 5319, 5, 499, 0, 0, 5319, 631, 1, 0, 0, 0, 5320, 5321, 5, 419, 0, 0, 5321, + 5322, 5, 55, 0, 0, 5322, 5323, 5, 503, 0, 0, 5323, 5324, 5, 499, 0, 0, + 5324, 5325, 5, 75, 0, 0, 5325, 5380, 5, 503, 0, 0, 5326, 5327, 5, 419, + 0, 0, 5327, 5328, 5, 56, 0, 0, 5328, 5380, 5, 503, 0, 0, 5329, 5330, 5, + 419, 0, 0, 5330, 5380, 5, 376, 0, 0, 5331, 5332, 5, 419, 0, 0, 5332, 5333, + 5, 503, 0, 0, 5333, 5334, 5, 64, 0, 0, 5334, 5380, 5, 503, 0, 0, 5335, + 5336, 5, 419, 0, 0, 5336, 5337, 5, 503, 0, 0, 5337, 5338, 5, 65, 0, 0, + 5338, 5380, 5, 503, 0, 0, 5339, 5340, 5, 419, 0, 0, 5340, 5341, 5, 503, + 0, 0, 5341, 5342, 5, 353, 0, 0, 5342, 5343, 5, 354, 0, 0, 5343, 5344, 5, + 349, 0, 0, 5344, 5357, 3, 686, 343, 0, 5345, 5346, 5, 356, 0, 0, 5346, + 5347, 5, 485, 0, 0, 5347, 5352, 3, 686, 343, 0, 5348, 5349, 5, 483, 0, + 0, 5349, 5351, 3, 686, 343, 0, 5350, 5348, 1, 0, 0, 0, 5351, 5354, 1, 0, + 0, 0, 5352, 5350, 1, 0, 0, 0, 5352, 5353, 1, 0, 0, 0, 5353, 5355, 1, 0, + 0, 0, 5354, 5352, 1, 0, 0, 0, 5355, 5356, 5, 486, 0, 0, 5356, 5358, 1, + 0, 0, 0, 5357, 5345, 1, 0, 0, 0, 5357, 5358, 1, 0, 0, 0, 5358, 5371, 1, + 0, 0, 0, 5359, 5360, 5, 357, 0, 0, 5360, 5361, 5, 485, 0, 0, 5361, 5366, + 3, 686, 343, 0, 5362, 5363, 5, 483, 0, 0, 5363, 5365, 3, 686, 343, 0, 5364, + 5362, 1, 0, 0, 0, 5365, 5368, 1, 0, 0, 0, 5366, 5364, 1, 0, 0, 0, 5366, + 5367, 1, 0, 0, 0, 5367, 5369, 1, 0, 0, 0, 5368, 5366, 1, 0, 0, 0, 5369, + 5370, 5, 486, 0, 0, 5370, 5372, 1, 0, 0, 0, 5371, 5359, 1, 0, 0, 0, 5371, + 5372, 1, 0, 0, 0, 5372, 5374, 1, 0, 0, 0, 5373, 5375, 5, 355, 0, 0, 5374, + 5373, 1, 0, 0, 0, 5374, 5375, 1, 0, 0, 0, 5375, 5380, 1, 0, 0, 0, 5376, + 5377, 5, 419, 0, 0, 5377, 5378, 5, 503, 0, 0, 5378, 5380, 3, 634, 317, + 0, 5379, 5320, 1, 0, 0, 0, 5379, 5326, 1, 0, 0, 0, 5379, 5329, 1, 0, 0, + 0, 5379, 5331, 1, 0, 0, 0, 5379, 5335, 1, 0, 0, 0, 5379, 5339, 1, 0, 0, + 0, 5379, 5376, 1, 0, 0, 0, 5380, 633, 1, 0, 0, 0, 5381, 5383, 8, 37, 0, + 0, 5382, 5381, 1, 0, 0, 0, 5383, 5384, 1, 0, 0, 0, 5384, 5382, 1, 0, 0, + 0, 5384, 5385, 1, 0, 0, 0, 5385, 635, 1, 0, 0, 0, 5386, 5387, 5, 348, 0, + 0, 5387, 5388, 5, 70, 0, 0, 5388, 5389, 3, 686, 343, 0, 5389, 5390, 5, + 345, 0, 0, 5390, 5391, 7, 25, 0, 0, 5391, 5392, 5, 349, 0, 0, 5392, 5393, + 3, 684, 342, 0, 5393, 5394, 5, 346, 0, 0, 5394, 5395, 5, 485, 0, 0, 5395, + 5400, 3, 638, 319, 0, 5396, 5397, 5, 483, 0, 0, 5397, 5399, 3, 638, 319, + 0, 5398, 5396, 1, 0, 0, 0, 5399, 5402, 1, 0, 0, 0, 5400, 5398, 1, 0, 0, + 0, 5400, 5401, 1, 0, 0, 0, 5401, 5403, 1, 0, 0, 0, 5402, 5400, 1, 0, 0, + 0, 5403, 5416, 5, 486, 0, 0, 5404, 5405, 5, 351, 0, 0, 5405, 5406, 5, 485, + 0, 0, 5406, 5411, 3, 640, 320, 0, 5407, 5408, 5, 483, 0, 0, 5408, 5410, + 3, 640, 320, 0, 5409, 5407, 1, 0, 0, 0, 5410, 5413, 1, 0, 0, 0, 5411, 5409, + 1, 0, 0, 0, 5411, 5412, 1, 0, 0, 0, 5412, 5414, 1, 0, 0, 0, 5413, 5411, + 1, 0, 0, 0, 5414, 5415, 5, 486, 0, 0, 5415, 5417, 1, 0, 0, 0, 5416, 5404, + 1, 0, 0, 0, 5416, 5417, 1, 0, 0, 0, 5417, 5420, 1, 0, 0, 0, 5418, 5419, + 5, 350, 0, 0, 5419, 5421, 5, 501, 0, 0, 5420, 5418, 1, 0, 0, 0, 5420, 5421, + 1, 0, 0, 0, 5421, 5424, 1, 0, 0, 0, 5422, 5423, 5, 74, 0, 0, 5423, 5425, + 5, 501, 0, 0, 5424, 5422, 1, 0, 0, 0, 5424, 5425, 1, 0, 0, 0, 5425, 637, + 1, 0, 0, 0, 5426, 5427, 3, 686, 343, 0, 5427, 5428, 5, 75, 0, 0, 5428, + 5429, 3, 686, 343, 0, 5429, 639, 1, 0, 0, 0, 5430, 5431, 3, 686, 343, 0, + 5431, 5432, 5, 411, 0, 0, 5432, 5433, 3, 686, 343, 0, 5433, 5434, 5, 92, + 0, 0, 5434, 5435, 3, 686, 343, 0, 5435, 5441, 1, 0, 0, 0, 5436, 5437, 3, + 686, 343, 0, 5437, 5438, 5, 411, 0, 0, 5438, 5439, 3, 686, 343, 0, 5439, + 5441, 1, 0, 0, 0, 5440, 5430, 1, 0, 0, 0, 5440, 5436, 1, 0, 0, 0, 5441, + 641, 1, 0, 0, 0, 5442, 5443, 5, 503, 0, 0, 5443, 643, 1, 0, 0, 0, 5444, + 5445, 5, 377, 0, 0, 5445, 5446, 5, 378, 0, 0, 5446, 5447, 3, 686, 343, + 0, 5447, 5448, 5, 75, 0, 0, 5448, 5449, 5, 487, 0, 0, 5449, 5450, 3, 368, + 184, 0, 5450, 5451, 5, 488, 0, 0, 5451, 645, 1, 0, 0, 0, 5452, 5453, 3, + 648, 324, 0, 5453, 647, 1, 0, 0, 0, 5454, 5459, 3, 650, 325, 0, 5455, 5456, + 5, 281, 0, 0, 5456, 5458, 3, 650, 325, 0, 5457, 5455, 1, 0, 0, 0, 5458, + 5461, 1, 0, 0, 0, 5459, 5457, 1, 0, 0, 0, 5459, 5460, 1, 0, 0, 0, 5460, + 649, 1, 0, 0, 0, 5461, 5459, 1, 0, 0, 0, 5462, 5467, 3, 652, 326, 0, 5463, + 5464, 5, 280, 0, 0, 5464, 5466, 3, 652, 326, 0, 5465, 5463, 1, 0, 0, 0, + 5466, 5469, 1, 0, 0, 0, 5467, 5465, 1, 0, 0, 0, 5467, 5468, 1, 0, 0, 0, + 5468, 651, 1, 0, 0, 0, 5469, 5467, 1, 0, 0, 0, 5470, 5472, 5, 282, 0, 0, + 5471, 5470, 1, 0, 0, 0, 5471, 5472, 1, 0, 0, 0, 5472, 5473, 1, 0, 0, 0, + 5473, 5474, 3, 654, 327, 0, 5474, 653, 1, 0, 0, 0, 5475, 5504, 3, 658, + 329, 0, 5476, 5477, 3, 656, 328, 0, 5477, 5478, 3, 658, 329, 0, 5478, 5505, + 1, 0, 0, 0, 5479, 5505, 5, 6, 0, 0, 5480, 5505, 5, 5, 0, 0, 5481, 5482, + 5, 284, 0, 0, 5482, 5485, 5, 485, 0, 0, 5483, 5486, 3, 560, 280, 0, 5484, + 5486, 3, 682, 341, 0, 5485, 5483, 1, 0, 0, 0, 5485, 5484, 1, 0, 0, 0, 5486, + 5487, 1, 0, 0, 0, 5487, 5488, 5, 486, 0, 0, 5488, 5505, 1, 0, 0, 0, 5489, + 5491, 5, 282, 0, 0, 5490, 5489, 1, 0, 0, 0, 5490, 5491, 1, 0, 0, 0, 5491, + 5492, 1, 0, 0, 0, 5492, 5493, 5, 285, 0, 0, 5493, 5494, 3, 658, 329, 0, + 5494, 5495, 5, 280, 0, 0, 5495, 5496, 3, 658, 329, 0, 5496, 5505, 1, 0, + 0, 0, 5497, 5499, 5, 282, 0, 0, 5498, 5497, 1, 0, 0, 0, 5498, 5499, 1, + 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5501, 5, 286, 0, 0, 5501, 5505, + 3, 658, 329, 0, 5502, 5503, 5, 287, 0, 0, 5503, 5505, 3, 658, 329, 0, 5504, + 5476, 1, 0, 0, 0, 5504, 5479, 1, 0, 0, 0, 5504, 5480, 1, 0, 0, 0, 5504, + 5481, 1, 0, 0, 0, 5504, 5490, 1, 0, 0, 0, 5504, 5498, 1, 0, 0, 0, 5504, + 5502, 1, 0, 0, 0, 5504, 5505, 1, 0, 0, 0, 5505, 655, 1, 0, 0, 0, 5506, + 5507, 7, 38, 0, 0, 5507, 657, 1, 0, 0, 0, 5508, 5513, 3, 660, 330, 0, 5509, + 5510, 7, 39, 0, 0, 5510, 5512, 3, 660, 330, 0, 5511, 5509, 1, 0, 0, 0, + 5512, 5515, 1, 0, 0, 0, 5513, 5511, 1, 0, 0, 0, 5513, 5514, 1, 0, 0, 0, + 5514, 659, 1, 0, 0, 0, 5515, 5513, 1, 0, 0, 0, 5516, 5521, 3, 662, 331, + 0, 5517, 5518, 7, 40, 0, 0, 5518, 5520, 3, 662, 331, 0, 5519, 5517, 1, + 0, 0, 0, 5520, 5523, 1, 0, 0, 0, 5521, 5519, 1, 0, 0, 0, 5521, 5522, 1, + 0, 0, 0, 5522, 661, 1, 0, 0, 0, 5523, 5521, 1, 0, 0, 0, 5524, 5526, 7, + 39, 0, 0, 5525, 5524, 1, 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5527, 1, + 0, 0, 0, 5527, 5528, 3, 664, 332, 0, 5528, 663, 1, 0, 0, 0, 5529, 5530, + 5, 485, 0, 0, 5530, 5531, 3, 646, 323, 0, 5531, 5532, 5, 486, 0, 0, 5532, + 5550, 1, 0, 0, 0, 5533, 5534, 5, 485, 0, 0, 5534, 5535, 3, 560, 280, 0, + 5535, 5536, 5, 486, 0, 0, 5536, 5550, 1, 0, 0, 0, 5537, 5538, 5, 288, 0, + 0, 5538, 5539, 5, 485, 0, 0, 5539, 5540, 3, 560, 280, 0, 5540, 5541, 5, + 486, 0, 0, 5541, 5550, 1, 0, 0, 0, 5542, 5550, 3, 666, 333, 0, 5543, 5550, + 3, 668, 334, 0, 5544, 5550, 3, 292, 146, 0, 5545, 5550, 3, 284, 142, 0, + 5546, 5550, 3, 672, 336, 0, 5547, 5550, 3, 674, 337, 0, 5548, 5550, 3, + 680, 340, 0, 5549, 5529, 1, 0, 0, 0, 5549, 5533, 1, 0, 0, 0, 5549, 5537, + 1, 0, 0, 0, 5549, 5542, 1, 0, 0, 0, 5549, 5543, 1, 0, 0, 0, 5549, 5544, + 1, 0, 0, 0, 5549, 5545, 1, 0, 0, 0, 5549, 5546, 1, 0, 0, 0, 5549, 5547, + 1, 0, 0, 0, 5549, 5548, 1, 0, 0, 0, 5550, 665, 1, 0, 0, 0, 5551, 5557, + 5, 78, 0, 0, 5552, 5553, 5, 79, 0, 0, 5553, 5554, 3, 646, 323, 0, 5554, + 5555, 5, 80, 0, 0, 5555, 5556, 3, 646, 323, 0, 5556, 5558, 1, 0, 0, 0, + 5557, 5552, 1, 0, 0, 0, 5558, 5559, 1, 0, 0, 0, 5559, 5557, 1, 0, 0, 0, + 5559, 5560, 1, 0, 0, 0, 5560, 5563, 1, 0, 0, 0, 5561, 5562, 5, 81, 0, 0, + 5562, 5564, 3, 646, 323, 0, 5563, 5561, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, + 0, 5564, 5565, 1, 0, 0, 0, 5565, 5566, 5, 82, 0, 0, 5566, 667, 1, 0, 0, + 0, 5567, 5568, 5, 279, 0, 0, 5568, 5569, 5, 485, 0, 0, 5569, 5570, 3, 646, + 323, 0, 5570, 5571, 5, 75, 0, 0, 5571, 5572, 3, 670, 335, 0, 5572, 5573, + 5, 486, 0, 0, 5573, 669, 1, 0, 0, 0, 5574, 5575, 7, 41, 0, 0, 5575, 671, + 1, 0, 0, 0, 5576, 5577, 7, 42, 0, 0, 5577, 5583, 5, 485, 0, 0, 5578, 5580, + 5, 83, 0, 0, 5579, 5578, 1, 0, 0, 0, 5579, 5580, 1, 0, 0, 0, 5580, 5581, + 1, 0, 0, 0, 5581, 5584, 3, 646, 323, 0, 5582, 5584, 5, 477, 0, 0, 5583, + 5579, 1, 0, 0, 0, 5583, 5582, 1, 0, 0, 0, 5584, 5585, 1, 0, 0, 0, 5585, + 5586, 5, 486, 0, 0, 5586, 673, 1, 0, 0, 0, 5587, 5588, 3, 676, 338, 0, + 5588, 5590, 5, 485, 0, 0, 5589, 5591, 3, 678, 339, 0, 5590, 5589, 1, 0, + 0, 0, 5590, 5591, 1, 0, 0, 0, 5591, 5592, 1, 0, 0, 0, 5592, 5593, 5, 486, + 0, 0, 5593, 675, 1, 0, 0, 0, 5594, 5595, 7, 43, 0, 0, 5595, 677, 1, 0, + 0, 0, 5596, 5601, 3, 646, 323, 0, 5597, 5598, 5, 483, 0, 0, 5598, 5600, + 3, 646, 323, 0, 5599, 5597, 1, 0, 0, 0, 5600, 5603, 1, 0, 0, 0, 5601, 5599, + 1, 0, 0, 0, 5601, 5602, 1, 0, 0, 0, 5602, 679, 1, 0, 0, 0, 5603, 5601, + 1, 0, 0, 0, 5604, 5617, 3, 688, 344, 0, 5605, 5610, 5, 502, 0, 0, 5606, + 5607, 5, 484, 0, 0, 5607, 5609, 3, 98, 49, 0, 5608, 5606, 1, 0, 0, 0, 5609, + 5612, 1, 0, 0, 0, 5610, 5608, 1, 0, 0, 0, 5610, 5611, 1, 0, 0, 0, 5611, + 5617, 1, 0, 0, 0, 5612, 5610, 1, 0, 0, 0, 5613, 5617, 3, 684, 342, 0, 5614, + 5617, 5, 503, 0, 0, 5615, 5617, 5, 498, 0, 0, 5616, 5604, 1, 0, 0, 0, 5616, + 5605, 1, 0, 0, 0, 5616, 5613, 1, 0, 0, 0, 5616, 5614, 1, 0, 0, 0, 5616, + 5615, 1, 0, 0, 0, 5617, 681, 1, 0, 0, 0, 5618, 5623, 3, 646, 323, 0, 5619, + 5620, 5, 483, 0, 0, 5620, 5622, 3, 646, 323, 0, 5621, 5619, 1, 0, 0, 0, + 5622, 5625, 1, 0, 0, 0, 5623, 5621, 1, 0, 0, 0, 5623, 5624, 1, 0, 0, 0, + 5624, 683, 1, 0, 0, 0, 5625, 5623, 1, 0, 0, 0, 5626, 5631, 3, 686, 343, + 0, 5627, 5628, 5, 484, 0, 0, 5628, 5630, 3, 686, 343, 0, 5629, 5627, 1, + 0, 0, 0, 5630, 5633, 1, 0, 0, 0, 5631, 5629, 1, 0, 0, 0, 5631, 5632, 1, + 0, 0, 0, 5632, 685, 1, 0, 0, 0, 5633, 5631, 1, 0, 0, 0, 5634, 5638, 5, + 503, 0, 0, 5635, 5638, 5, 505, 0, 0, 5636, 5638, 3, 708, 354, 0, 5637, + 5634, 1, 0, 0, 0, 5637, 5635, 1, 0, 0, 0, 5637, 5636, 1, 0, 0, 0, 5638, + 687, 1, 0, 0, 0, 5639, 5645, 5, 499, 0, 0, 5640, 5645, 5, 501, 0, 0, 5641, + 5645, 3, 692, 346, 0, 5642, 5645, 5, 283, 0, 0, 5643, 5645, 5, 138, 0, + 0, 5644, 5639, 1, 0, 0, 0, 5644, 5640, 1, 0, 0, 0, 5644, 5641, 1, 0, 0, + 0, 5644, 5642, 1, 0, 0, 0, 5644, 5643, 1, 0, 0, 0, 5645, 689, 1, 0, 0, + 0, 5646, 5655, 5, 489, 0, 0, 5647, 5652, 3, 688, 344, 0, 5648, 5649, 5, + 483, 0, 0, 5649, 5651, 3, 688, 344, 0, 5650, 5648, 1, 0, 0, 0, 5651, 5654, + 1, 0, 0, 0, 5652, 5650, 1, 0, 0, 0, 5652, 5653, 1, 0, 0, 0, 5653, 5656, + 1, 0, 0, 0, 5654, 5652, 1, 0, 0, 0, 5655, 5647, 1, 0, 0, 0, 5655, 5656, + 1, 0, 0, 0, 5656, 5657, 1, 0, 0, 0, 5657, 5658, 5, 490, 0, 0, 5658, 691, + 1, 0, 0, 0, 5659, 5660, 7, 44, 0, 0, 5660, 693, 1, 0, 0, 0, 5661, 5662, + 5, 2, 0, 0, 5662, 695, 1, 0, 0, 0, 5663, 5664, 5, 492, 0, 0, 5664, 5670, + 3, 698, 349, 0, 5665, 5666, 5, 485, 0, 0, 5666, 5667, 3, 700, 350, 0, 5667, + 5668, 5, 486, 0, 0, 5668, 5671, 1, 0, 0, 0, 5669, 5671, 3, 704, 352, 0, + 5670, 5665, 1, 0, 0, 0, 5670, 5669, 1, 0, 0, 0, 5670, 5671, 1, 0, 0, 0, + 5671, 697, 1, 0, 0, 0, 5672, 5673, 7, 45, 0, 0, 5673, 699, 1, 0, 0, 0, + 5674, 5679, 3, 702, 351, 0, 5675, 5676, 5, 483, 0, 0, 5676, 5678, 3, 702, + 351, 0, 5677, 5675, 1, 0, 0, 0, 5678, 5681, 1, 0, 0, 0, 5679, 5677, 1, + 0, 0, 0, 5679, 5680, 1, 0, 0, 0, 5680, 701, 1, 0, 0, 0, 5681, 5679, 1, + 0, 0, 0, 5682, 5683, 5, 503, 0, 0, 5683, 5684, 5, 491, 0, 0, 5684, 5687, + 3, 704, 352, 0, 5685, 5687, 3, 704, 352, 0, 5686, 5682, 1, 0, 0, 0, 5686, + 5685, 1, 0, 0, 0, 5687, 703, 1, 0, 0, 0, 5688, 5692, 3, 688, 344, 0, 5689, + 5692, 3, 646, 323, 0, 5690, 5692, 3, 684, 342, 0, 5691, 5688, 1, 0, 0, + 0, 5691, 5689, 1, 0, 0, 0, 5691, 5690, 1, 0, 0, 0, 5692, 705, 1, 0, 0, + 0, 5693, 5694, 7, 46, 0, 0, 5694, 707, 1, 0, 0, 0, 5695, 5696, 7, 47, 0, + 0, 5696, 709, 1, 0, 0, 0, 666, 713, 719, 724, 727, 730, 739, 749, 758, + 764, 766, 770, 773, 778, 784, 806, 814, 822, 830, 838, 850, 863, 876, 888, + 899, 903, 911, 917, 934, 938, 942, 946, 950, 952, 966, 975, 984, 1000, + 1009, 1024, 1038, 1042, 1051, 1054, 1062, 1067, 1069, 1127, 1140, 1151, + 1160, 1162, 1173, 1179, 1187, 1189, 1210, 1218, 1235, 1259, 1275, 1359, + 1369, 1377, 1391, 1398, 1406, 1420, 1433, 1437, 1443, 1446, 1452, 1455, + 1461, 1465, 1469, 1475, 1480, 1483, 1485, 1491, 1495, 1499, 1502, 1506, + 1511, 1518, 1525, 1529, 1534, 1543, 1549, 1554, 1560, 1565, 1570, 1575, + 1579, 1582, 1584, 1590, 1622, 1630, 1651, 1654, 1665, 1670, 1675, 1684, + 1689, 1701, 1730, 1740, 1761, 1775, 1782, 1795, 1802, 1810, 1815, 1820, + 1826, 1834, 1841, 1845, 1849, 1852, 1869, 1874, 1913, 1928, 1935, 1943, + 1950, 1954, 1957, 1963, 1966, 1973, 1977, 1980, 1985, 1992, 1999, 2015, + 2020, 2028, 2034, 2039, 2045, 2050, 2056, 2061, 2066, 2071, 2076, 2081, + 2086, 2091, 2096, 2101, 2106, 2111, 2116, 2121, 2126, 2131, 2136, 2141, + 2146, 2151, 2156, 2161, 2166, 2171, 2176, 2181, 2186, 2191, 2196, 2201, + 2206, 2211, 2216, 2221, 2226, 2231, 2236, 2241, 2246, 2251, 2256, 2261, + 2266, 2271, 2276, 2281, 2286, 2291, 2296, 2301, 2306, 2311, 2316, 2321, + 2326, 2331, 2336, 2341, 2346, 2351, 2356, 2361, 2366, 2371, 2373, 2380, + 2385, 2392, 2398, 2401, 2404, 2410, 2413, 2419, 2423, 2429, 2432, 2435, + 2440, 2445, 2454, 2456, 2464, 2467, 2471, 2475, 2478, 2487, 2509, 2522, + 2527, 2537, 2547, 2552, 2560, 2567, 2571, 2575, 2586, 2593, 2607, 2614, + 2618, 2622, 2630, 2634, 2638, 2648, 2650, 2654, 2657, 2662, 2665, 2668, + 2672, 2680, 2684, 2691, 2696, 2706, 2709, 2713, 2717, 2724, 2731, 2737, + 2751, 2758, 2773, 2777, 2784, 2789, 2793, 2796, 2799, 2803, 2809, 2827, + 2832, 2840, 2859, 2924, 2931, 2936, 2966, 2989, 3000, 3007, 3024, 3027, + 3036, 3046, 3058, 3070, 3081, 3084, 3097, 3105, 3111, 3117, 3125, 3132, + 3140, 3147, 3154, 3166, 3169, 3181, 3205, 3213, 3221, 3241, 3245, 3247, + 3255, 3260, 3263, 3273, 3353, 3363, 3371, 3381, 3385, 3387, 3395, 3398, + 3403, 3408, 3414, 3418, 3422, 3428, 3434, 3439, 3444, 3449, 3454, 3462, + 3473, 3478, 3484, 3488, 3497, 3499, 3501, 3509, 3545, 3548, 3551, 3559, + 3566, 3577, 3586, 3592, 3600, 3609, 3617, 3623, 3627, 3636, 3648, 3654, + 3656, 3669, 3673, 3685, 3690, 3692, 3707, 3712, 3725, 3733, 3744, 3754, + 3763, 3770, 3780, 3791, 3810, 3815, 3826, 3831, 3837, 3841, 3849, 3852, + 3868, 3876, 3879, 3886, 3894, 3899, 3902, 3905, 3915, 3918, 3925, 3928, + 3936, 3954, 3960, 3963, 3968, 3973, 3983, 4002, 4010, 4022, 4029, 4033, + 4047, 4051, 4055, 4060, 4065, 4070, 4077, 4080, 4085, 4115, 4123, 4128, + 4133, 4137, 4142, 4146, 4152, 4154, 4161, 4163, 4172, 4177, 4182, 4186, + 4191, 4195, 4201, 4203, 4210, 4212, 4214, 4219, 4225, 4231, 4237, 4241, + 4247, 4249, 4261, 4270, 4275, 4281, 4283, 4290, 4292, 4303, 4312, 4317, + 4321, 4325, 4331, 4333, 4345, 4350, 4363, 4369, 4373, 4380, 4387, 4389, + 4400, 4410, 4419, 4422, 4434, 4440, 4449, 4451, 4458, 4460, 4467, 4469, + 4476, 4478, 4485, 4487, 4494, 4496, 4503, 4505, 4512, 4514, 4521, 4523, + 4530, 4532, 4539, 4541, 4549, 4551, 4579, 4586, 4602, 4607, 4618, 4620, + 4653, 4655, 4663, 4665, 4673, 4675, 4683, 4685, 4694, 4704, 4710, 4715, + 4717, 4720, 4729, 4731, 4740, 4742, 4750, 4752, 4764, 4766, 4768, 4776, + 4782, 4784, 4789, 4791, 4801, 4811, 4852, 4882, 4891, 4927, 4931, 4939, + 4942, 4947, 4952, 4958, 4960, 4964, 4968, 4972, 4975, 4982, 4985, 4989, + 4996, 5001, 5006, 5009, 5012, 5015, 5018, 5021, 5025, 5028, 5031, 5035, + 5038, 5040, 5044, 5054, 5057, 5062, 5067, 5069, 5073, 5080, 5085, 5088, + 5094, 5097, 5099, 5102, 5108, 5111, 5116, 5119, 5121, 5133, 5137, 5141, + 5146, 5149, 5168, 5173, 5180, 5187, 5193, 5195, 5213, 5224, 5239, 5241, + 5249, 5252, 5255, 5258, 5261, 5277, 5281, 5286, 5294, 5302, 5309, 5352, + 5357, 5366, 5371, 5374, 5379, 5384, 5400, 5411, 5416, 5420, 5424, 5440, + 5459, 5467, 5471, 5485, 5490, 5498, 5504, 5513, 5521, 5525, 5549, 5559, + 5563, 5579, 5583, 5590, 5601, 5610, 5616, 5623, 5631, 5637, 5644, 5652, + 5655, 5670, 5679, 5686, 5691, } deserializer := antlr.NewATNDeserializer(nil) staticData.atn = deserializer.Deserialize(staticData.serializedATN) @@ -3321,186 +3560,207 @@ const ( MDLParserEXPRESSION = 302 MDLParserXPATH = 303 MDLParserCONSTRAINT = 304 - MDLParserREST = 305 - MDLParserSERVICE = 306 - MDLParserSERVICES = 307 - MDLParserODATA = 308 - MDLParserBASE = 309 - MDLParserAUTH = 310 - MDLParserAUTHENTICATION = 311 - MDLParserBASIC = 312 - MDLParserNOTHING = 313 - MDLParserOAUTH = 314 - MDLParserOPERATION = 315 - MDLParserMETHOD = 316 - MDLParserPATH = 317 - MDLParserTIMEOUT = 318 - MDLParserBODY = 319 - MDLParserRESPONSE = 320 - MDLParserREQUEST = 321 - MDLParserJSON = 322 - MDLParserXML = 323 - MDLParserSTATUS = 324 - MDLParserVERSION = 325 - MDLParserGET = 326 - MDLParserPOST = 327 - MDLParserPUT = 328 - MDLParserPATCH = 329 - MDLParserAPI = 330 - MDLParserCLIENT = 331 - MDLParserCLIENTS = 332 - MDLParserPUBLISH = 333 - MDLParserEXPOSE = 334 - MDLParserNAMESPACE_KW = 335 - MDLParserSESSION = 336 - MDLParserGUEST = 337 - MDLParserPAGING = 338 - MDLParserNOT_SUPPORTED = 339 - MDLParserUSERNAME = 340 - MDLParserPASSWORD = 341 - MDLParserCONNECTION = 342 - MDLParserDATABASE = 343 - MDLParserQUERY = 344 - MDLParserMAP = 345 - MDLParserMAPPING = 346 - MDLParserIMPORT = 347 - MDLParserINTO = 348 - MDLParserBATCH = 349 - MDLParserLINK = 350 - MDLParserEXPORT = 351 - MDLParserGENERATE = 352 - MDLParserCONNECTOR = 353 - MDLParserEXEC = 354 - MDLParserTABLES = 355 - MDLParserVIEWS = 356 - MDLParserEXPOSED = 357 - MDLParserPARAMETER = 358 - MDLParserPARAMETERS = 359 - MDLParserHEADERS = 360 - MDLParserNAVIGATION = 361 - MDLParserMENU_KW = 362 - MDLParserHOMES = 363 - MDLParserHOME = 364 - MDLParserLOGIN = 365 - MDLParserFOUND = 366 - MDLParserMODULES = 367 - MDLParserENTITIES = 368 - MDLParserASSOCIATIONS = 369 - MDLParserMICROFLOWS = 370 - MDLParserNANOFLOWS = 371 - MDLParserWORKFLOWS = 372 - MDLParserENUMERATIONS = 373 - MDLParserCONSTANTS = 374 - MDLParserCONNECTIONS = 375 - MDLParserDEFINE = 376 - MDLParserFRAGMENT = 377 - MDLParserFRAGMENTS = 378 - MDLParserINSERT = 379 - MDLParserBEFORE = 380 - MDLParserAFTER = 381 - MDLParserUPDATE = 382 - MDLParserREFRESH = 383 - MDLParserCHECK = 384 - MDLParserBUILD = 385 - MDLParserEXECUTE = 386 - MDLParserSCRIPT = 387 - MDLParserLINT = 388 - MDLParserRULES = 389 - MDLParserTEXT = 390 - MDLParserSARIF = 391 - MDLParserMESSAGE = 392 - MDLParserCOMMENT = 393 - MDLParserCATALOG = 394 - MDLParserFORCE = 395 - MDLParserBACKGROUND = 396 - MDLParserCALLERS = 397 - MDLParserCALLEES = 398 - MDLParserREFERENCES = 399 - MDLParserTRANSITIVE = 400 - MDLParserIMPACT = 401 - MDLParserDEPTH = 402 - MDLParserSTRUCTURE = 403 - MDLParserTYPE = 404 - MDLParserVALUE = 405 - MDLParserSINGLE = 406 - MDLParserMULTIPLE = 407 - MDLParserNONE = 408 - MDLParserBOTH = 409 - MDLParserTO = 410 - MDLParserOF = 411 - MDLParserOVER = 412 - MDLParserFOR = 413 - MDLParserREPLACE = 414 - MDLParserMEMBERS = 415 - MDLParserATTRIBUTE_NAME = 416 - MDLParserFORMAT = 417 - MDLParserSQL = 418 - MDLParserWITHOUT = 419 - MDLParserDRY = 420 - MDLParserRUN = 421 - MDLParserWIDGETTYPE = 422 - MDLParserV3 = 423 - MDLParserBUSINESS = 424 - MDLParserEVENT = 425 - MDLParserSUBSCRIBE = 426 - MDLParserSETTINGS = 427 - MDLParserCONFIGURATION = 428 - MDLParserSECURITY = 429 - MDLParserROLE = 430 - MDLParserROLES = 431 - MDLParserGRANT = 432 - MDLParserREVOKE = 433 - MDLParserPRODUCTION = 434 - MDLParserPROTOTYPE = 435 - MDLParserMANAGE = 436 - MDLParserDEMO = 437 - MDLParserMATRIX = 438 - MDLParserAPPLY = 439 - MDLParserACCESS = 440 - MDLParserLEVEL = 441 - MDLParserUSER = 442 - MDLParserREAD = 443 - MDLParserWRITE = 444 - MDLParserDESCRIPTION = 445 - MDLParserOFF = 446 - MDLParserUSERS = 447 - MDLParserNOT_EQUALS = 448 - MDLParserLESS_THAN_OR_EQUAL = 449 - MDLParserGREATER_THAN_OR_EQUAL = 450 - MDLParserEQUALS = 451 - MDLParserLESS_THAN = 452 - MDLParserGREATER_THAN = 453 - MDLParserPLUS = 454 - MDLParserMINUS = 455 - MDLParserSTAR = 456 - MDLParserSLASH = 457 - MDLParserPERCENT = 458 - MDLParserMOD = 459 - MDLParserDIV = 460 - MDLParserSEMICOLON = 461 - MDLParserCOMMA = 462 - MDLParserDOT = 463 - MDLParserLPAREN = 464 - MDLParserRPAREN = 465 - MDLParserLBRACE = 466 - MDLParserRBRACE = 467 - MDLParserLBRACKET = 468 - MDLParserRBRACKET = 469 - MDLParserCOLON = 470 - MDLParserAT = 471 - MDLParserPIPE = 472 - MDLParserDOUBLE_COLON = 473 - MDLParserARROW = 474 - MDLParserQUESTION = 475 - MDLParserHASH = 476 - MDLParserMENDIX_TOKEN = 477 - MDLParserSTRING_LITERAL = 478 - MDLParserDOLLAR_STRING = 479 - MDLParserNUMBER_LITERAL = 480 - MDLParserVARIABLE = 481 - MDLParserIDENTIFIER = 482 - MDLParserHYPHENATED_ID = 483 - MDLParserQUOTED_IDENTIFIER = 484 + MDLParserCALCULATED = 305 + MDLParserREST = 306 + MDLParserSERVICE = 307 + MDLParserSERVICES = 308 + MDLParserODATA = 309 + MDLParserBASE = 310 + MDLParserAUTH = 311 + MDLParserAUTHENTICATION = 312 + MDLParserBASIC = 313 + MDLParserNOTHING = 314 + MDLParserOAUTH = 315 + MDLParserOPERATION = 316 + MDLParserMETHOD = 317 + MDLParserPATH = 318 + MDLParserTIMEOUT = 319 + MDLParserBODY = 320 + MDLParserRESPONSE = 321 + MDLParserREQUEST = 322 + MDLParserJSON = 323 + MDLParserXML = 324 + MDLParserSTATUS = 325 + MDLParserVERSION = 326 + MDLParserGET = 327 + MDLParserPOST = 328 + MDLParserPUT = 329 + MDLParserPATCH = 330 + MDLParserAPI = 331 + MDLParserCLIENT = 332 + MDLParserCLIENTS = 333 + MDLParserPUBLISH = 334 + MDLParserEXPOSE = 335 + MDLParserNAMESPACE_KW = 336 + MDLParserSESSION = 337 + MDLParserGUEST = 338 + MDLParserPAGING = 339 + MDLParserNOT_SUPPORTED = 340 + MDLParserUSERNAME = 341 + MDLParserPASSWORD = 342 + MDLParserCONNECTION = 343 + MDLParserDATABASE = 344 + MDLParserQUERY = 345 + MDLParserMAP = 346 + MDLParserMAPPING = 347 + MDLParserIMPORT = 348 + MDLParserINTO = 349 + MDLParserBATCH = 350 + MDLParserLINK = 351 + MDLParserEXPORT = 352 + MDLParserGENERATE = 353 + MDLParserCONNECTOR = 354 + MDLParserEXEC = 355 + MDLParserTABLES = 356 + MDLParserVIEWS = 357 + MDLParserEXPOSED = 358 + MDLParserPARAMETER = 359 + MDLParserPARAMETERS = 360 + MDLParserHEADERS = 361 + MDLParserNAVIGATION = 362 + MDLParserMENU_KW = 363 + MDLParserHOMES = 364 + MDLParserHOME = 365 + MDLParserLOGIN = 366 + MDLParserFOUND = 367 + MDLParserMODULES = 368 + MDLParserENTITIES = 369 + MDLParserASSOCIATIONS = 370 + MDLParserMICROFLOWS = 371 + MDLParserNANOFLOWS = 372 + MDLParserWORKFLOWS = 373 + MDLParserENUMERATIONS = 374 + MDLParserCONSTANTS = 375 + MDLParserCONNECTIONS = 376 + MDLParserDEFINE = 377 + MDLParserFRAGMENT = 378 + MDLParserFRAGMENTS = 379 + MDLParserINSERT = 380 + MDLParserBEFORE = 381 + MDLParserAFTER = 382 + MDLParserUPDATE = 383 + MDLParserREFRESH = 384 + MDLParserCHECK = 385 + MDLParserBUILD = 386 + MDLParserEXECUTE = 387 + MDLParserSCRIPT = 388 + MDLParserLINT = 389 + MDLParserRULES = 390 + MDLParserTEXT = 391 + MDLParserSARIF = 392 + MDLParserMESSAGE = 393 + MDLParserCOMMENT = 394 + MDLParserCATALOG = 395 + MDLParserFORCE = 396 + MDLParserBACKGROUND = 397 + MDLParserCALLERS = 398 + MDLParserCALLEES = 399 + MDLParserREFERENCES = 400 + MDLParserTRANSITIVE = 401 + MDLParserIMPACT = 402 + MDLParserDEPTH = 403 + MDLParserSTRUCTURE = 404 + MDLParserTYPE = 405 + MDLParserVALUE = 406 + MDLParserSINGLE = 407 + MDLParserMULTIPLE = 408 + MDLParserNONE = 409 + MDLParserBOTH = 410 + MDLParserTO = 411 + MDLParserOF = 412 + MDLParserOVER = 413 + MDLParserFOR = 414 + MDLParserREPLACE = 415 + MDLParserMEMBERS = 416 + MDLParserATTRIBUTE_NAME = 417 + MDLParserFORMAT = 418 + MDLParserSQL = 419 + MDLParserWITHOUT = 420 + MDLParserDRY = 421 + MDLParserRUN = 422 + MDLParserWIDGETTYPE = 423 + MDLParserV3 = 424 + MDLParserBUSINESS = 425 + MDLParserEVENT = 426 + MDLParserSUBSCRIBE = 427 + MDLParserSETTINGS = 428 + MDLParserCONFIGURATION = 429 + MDLParserSECURITY = 430 + MDLParserROLE = 431 + MDLParserROLES = 432 + MDLParserGRANT = 433 + MDLParserREVOKE = 434 + MDLParserPRODUCTION = 435 + MDLParserPROTOTYPE = 436 + MDLParserMANAGE = 437 + MDLParserDEMO = 438 + MDLParserMATRIX = 439 + MDLParserAPPLY = 440 + MDLParserACCESS = 441 + MDLParserLEVEL = 442 + MDLParserUSER = 443 + MDLParserTASK = 444 + MDLParserDECISION = 445 + MDLParserSPLIT = 446 + MDLParserOUTCOMES = 447 + MDLParserTARGETING = 448 + MDLParserNOTIFICATION = 449 + MDLParserTIMER = 450 + MDLParserJUMP = 451 + MDLParserDUE = 452 + MDLParserOVERVIEW = 453 + MDLParserDATE = 454 + MDLParserPARALLEL = 455 + MDLParserWAIT = 456 + MDLParserANNOTATION = 457 + MDLParserBOUNDARY = 458 + MDLParserINTERRUPTING = 459 + MDLParserNON = 460 + MDLParserMULTI = 461 + MDLParserBY = 462 + MDLParserREAD = 463 + MDLParserWRITE = 464 + MDLParserDESCRIPTION = 465 + MDLParserDISPLAY = 466 + MDLParserOFF = 467 + MDLParserUSERS = 468 + MDLParserNOT_EQUALS = 469 + MDLParserLESS_THAN_OR_EQUAL = 470 + MDLParserGREATER_THAN_OR_EQUAL = 471 + MDLParserEQUALS = 472 + MDLParserLESS_THAN = 473 + MDLParserGREATER_THAN = 474 + MDLParserPLUS = 475 + MDLParserMINUS = 476 + MDLParserSTAR = 477 + MDLParserSLASH = 478 + MDLParserPERCENT = 479 + MDLParserMOD = 480 + MDLParserDIV = 481 + MDLParserSEMICOLON = 482 + MDLParserCOMMA = 483 + MDLParserDOT = 484 + MDLParserLPAREN = 485 + MDLParserRPAREN = 486 + MDLParserLBRACE = 487 + MDLParserRBRACE = 488 + MDLParserLBRACKET = 489 + MDLParserRBRACKET = 490 + MDLParserCOLON = 491 + MDLParserAT = 492 + MDLParserPIPE = 493 + MDLParserDOUBLE_COLON = 494 + MDLParserARROW = 495 + MDLParserQUESTION = 496 + MDLParserHASH = 497 + MDLParserMENDIX_TOKEN = 498 + MDLParserSTRING_LITERAL = 499 + MDLParserDOLLAR_STRING = 500 + MDLParserNUMBER_LITERAL = 501 + MDLParserVARIABLE = 502 + MDLParserIDENTIFIER = 503 + MDLParserHYPHENATED_ID = 504 + MDLParserQUOTED_IDENTIFIER = 505 ) // MDLParser rules. @@ -3536,311 +3796,330 @@ const ( MDLParserRULE_revokeMicroflowAccessStatement = 28 MDLParserRULE_grantPageAccessStatement = 29 MDLParserRULE_revokePageAccessStatement = 30 - MDLParserRULE_grantODataServiceAccessStatement = 31 - MDLParserRULE_revokeODataServiceAccessStatement = 32 - MDLParserRULE_alterProjectSecurityStatement = 33 - MDLParserRULE_createDemoUserStatement = 34 - MDLParserRULE_dropDemoUserStatement = 35 - MDLParserRULE_updateSecurityStatement = 36 - MDLParserRULE_moduleRoleList = 37 - MDLParserRULE_entityAccessRightList = 38 - MDLParserRULE_entityAccessRight = 39 - MDLParserRULE_createEntityStatement = 40 - MDLParserRULE_generalizationClause = 41 - MDLParserRULE_entityBody = 42 - MDLParserRULE_entityOptions = 43 - MDLParserRULE_entityOption = 44 - MDLParserRULE_attributeDefinitionList = 45 - MDLParserRULE_attributeDefinition = 46 - MDLParserRULE_attributeName = 47 - MDLParserRULE_attributeConstraint = 48 - MDLParserRULE_dataType = 49 - MDLParserRULE_templateContext = 50 - MDLParserRULE_nonListDataType = 51 - MDLParserRULE_indexDefinition = 52 - MDLParserRULE_indexAttributeList = 53 - MDLParserRULE_indexAttribute = 54 - MDLParserRULE_indexColumnName = 55 - MDLParserRULE_createAssociationStatement = 56 - MDLParserRULE_associationOptions = 57 - MDLParserRULE_associationOption = 58 - MDLParserRULE_deleteBehavior = 59 - MDLParserRULE_alterEntityAction = 60 - MDLParserRULE_alterAssociationAction = 61 - MDLParserRULE_alterEnumerationAction = 62 - MDLParserRULE_alterNotebookAction = 63 - MDLParserRULE_createModuleStatement = 64 - MDLParserRULE_moduleOptions = 65 - MDLParserRULE_moduleOption = 66 - MDLParserRULE_createEnumerationStatement = 67 - MDLParserRULE_enumerationValueList = 68 - MDLParserRULE_enumerationValue = 69 - MDLParserRULE_enumValueName = 70 - MDLParserRULE_enumerationOptions = 71 - MDLParserRULE_enumerationOption = 72 - MDLParserRULE_createValidationRuleStatement = 73 - MDLParserRULE_validationRuleBody = 74 - MDLParserRULE_rangeConstraint = 75 - MDLParserRULE_attributeReference = 76 - MDLParserRULE_attributeReferenceList = 77 - MDLParserRULE_createMicroflowStatement = 78 - MDLParserRULE_createJavaActionStatement = 79 - MDLParserRULE_javaActionParameterList = 80 - MDLParserRULE_javaActionParameter = 81 - MDLParserRULE_javaActionReturnType = 82 - MDLParserRULE_javaActionExposedClause = 83 - MDLParserRULE_microflowParameterList = 84 - MDLParserRULE_microflowParameter = 85 - MDLParserRULE_parameterName = 86 - MDLParserRULE_microflowReturnType = 87 - MDLParserRULE_microflowOptions = 88 - MDLParserRULE_microflowOption = 89 - MDLParserRULE_microflowBody = 90 - MDLParserRULE_microflowStatement = 91 - MDLParserRULE_declareStatement = 92 - MDLParserRULE_setStatement = 93 - MDLParserRULE_createObjectStatement = 94 - MDLParserRULE_changeObjectStatement = 95 - MDLParserRULE_attributePath = 96 - MDLParserRULE_commitStatement = 97 - MDLParserRULE_deleteObjectStatement = 98 - MDLParserRULE_rollbackStatement = 99 - MDLParserRULE_retrieveStatement = 100 - MDLParserRULE_retrieveSource = 101 - MDLParserRULE_onErrorClause = 102 - MDLParserRULE_ifStatement = 103 - MDLParserRULE_loopStatement = 104 - MDLParserRULE_whileStatement = 105 - MDLParserRULE_continueStatement = 106 - MDLParserRULE_breakStatement = 107 - MDLParserRULE_returnStatement = 108 - MDLParserRULE_raiseErrorStatement = 109 - MDLParserRULE_logStatement = 110 - MDLParserRULE_logLevel = 111 - MDLParserRULE_templateParams = 112 - MDLParserRULE_templateParam = 113 - MDLParserRULE_logTemplateParams = 114 - MDLParserRULE_logTemplateParam = 115 - MDLParserRULE_callMicroflowStatement = 116 - MDLParserRULE_callJavaActionStatement = 117 - MDLParserRULE_executeDatabaseQueryStatement = 118 - MDLParserRULE_callExternalActionStatement = 119 - MDLParserRULE_callArgumentList = 120 - MDLParserRULE_callArgument = 121 - MDLParserRULE_showPageStatement = 122 - MDLParserRULE_showPageArgList = 123 - MDLParserRULE_showPageArg = 124 - MDLParserRULE_closePageStatement = 125 - MDLParserRULE_showHomePageStatement = 126 - MDLParserRULE_showMessageStatement = 127 - MDLParserRULE_throwStatement = 128 - MDLParserRULE_validationFeedbackStatement = 129 - MDLParserRULE_restCallStatement = 130 - MDLParserRULE_httpMethod = 131 - MDLParserRULE_restCallUrl = 132 - MDLParserRULE_restCallUrlParams = 133 - MDLParserRULE_restCallHeaderClause = 134 - MDLParserRULE_restCallAuthClause = 135 - MDLParserRULE_restCallBodyClause = 136 - MDLParserRULE_restCallTimeoutClause = 137 - MDLParserRULE_restCallReturnsClause = 138 - MDLParserRULE_listOperationStatement = 139 - MDLParserRULE_listOperation = 140 - MDLParserRULE_sortSpecList = 141 - MDLParserRULE_sortSpec = 142 - MDLParserRULE_aggregateListStatement = 143 - MDLParserRULE_listAggregateOperation = 144 - MDLParserRULE_createListStatement = 145 - MDLParserRULE_addToListStatement = 146 - MDLParserRULE_removeFromListStatement = 147 - MDLParserRULE_memberAssignmentList = 148 - MDLParserRULE_memberAssignment = 149 - MDLParserRULE_memberAttributeName = 150 - MDLParserRULE_changeList = 151 - MDLParserRULE_changeItem = 152 - MDLParserRULE_createPageStatement = 153 - MDLParserRULE_createSnippetStatement = 154 - MDLParserRULE_snippetOptions = 155 - MDLParserRULE_snippetOption = 156 - MDLParserRULE_pageParameterList = 157 - MDLParserRULE_pageParameter = 158 - MDLParserRULE_snippetParameterList = 159 - MDLParserRULE_snippetParameter = 160 - MDLParserRULE_variableDeclarationList = 161 - MDLParserRULE_variableDeclaration = 162 - MDLParserRULE_sortColumn = 163 - MDLParserRULE_xpathConstraint = 164 - MDLParserRULE_andOrXpath = 165 - MDLParserRULE_xpathExpr = 166 - MDLParserRULE_xpathAndExpr = 167 - MDLParserRULE_xpathNotExpr = 168 - MDLParserRULE_xpathComparisonExpr = 169 - MDLParserRULE_xpathValueExpr = 170 - MDLParserRULE_xpathPath = 171 - MDLParserRULE_xpathStep = 172 - MDLParserRULE_xpathStepValue = 173 - MDLParserRULE_xpathQualifiedName = 174 - MDLParserRULE_xpathWord = 175 - MDLParserRULE_xpathFunctionCall = 176 - MDLParserRULE_xpathFunctionName = 177 - MDLParserRULE_pageHeaderV3 = 178 - MDLParserRULE_pageHeaderPropertyV3 = 179 - MDLParserRULE_snippetHeaderV3 = 180 - MDLParserRULE_snippetHeaderPropertyV3 = 181 - MDLParserRULE_pageBodyV3 = 182 - MDLParserRULE_useFragmentRef = 183 - MDLParserRULE_widgetV3 = 184 - MDLParserRULE_widgetTypeV3 = 185 - MDLParserRULE_widgetPropertiesV3 = 186 - MDLParserRULE_widgetPropertyV3 = 187 - MDLParserRULE_filterTypeValue = 188 - MDLParserRULE_attributeListV3 = 189 - MDLParserRULE_dataSourceExprV3 = 190 - MDLParserRULE_actionExprV3 = 191 - MDLParserRULE_microflowArgsV3 = 192 - MDLParserRULE_microflowArgV3 = 193 - MDLParserRULE_attributePathV3 = 194 - MDLParserRULE_stringExprV3 = 195 - MDLParserRULE_paramListV3 = 196 - MDLParserRULE_paramAssignmentV3 = 197 - MDLParserRULE_renderModeV3 = 198 - MDLParserRULE_buttonStyleV3 = 199 - MDLParserRULE_desktopWidthV3 = 200 - MDLParserRULE_selectionModeV3 = 201 - MDLParserRULE_propertyValueV3 = 202 - MDLParserRULE_designPropertyListV3 = 203 - MDLParserRULE_designPropertyEntryV3 = 204 - MDLParserRULE_widgetBodyV3 = 205 - MDLParserRULE_createNotebookStatement = 206 - MDLParserRULE_notebookOptions = 207 - MDLParserRULE_notebookOption = 208 - MDLParserRULE_notebookPage = 209 - MDLParserRULE_createDatabaseConnectionStatement = 210 - MDLParserRULE_databaseConnectionOption = 211 - MDLParserRULE_databaseQuery = 212 - MDLParserRULE_databaseQueryMapping = 213 - MDLParserRULE_createConstantStatement = 214 - MDLParserRULE_constantOptions = 215 - MDLParserRULE_constantOption = 216 - MDLParserRULE_createRestClientStatement = 217 - MDLParserRULE_restClientOptions = 218 - MDLParserRULE_restClientOption = 219 - MDLParserRULE_restAuthentication = 220 - MDLParserRULE_restOperation = 221 - MDLParserRULE_restMethod = 222 - MDLParserRULE_restOperationOptions = 223 - MDLParserRULE_restOperationOption = 224 - MDLParserRULE_restResponse = 225 - MDLParserRULE_restParameter = 226 - MDLParserRULE_createIndexStatement = 227 - MDLParserRULE_createODataClientStatement = 228 - MDLParserRULE_createODataServiceStatement = 229 - MDLParserRULE_odataPropertyValue = 230 - MDLParserRULE_odataPropertyAssignment = 231 - MDLParserRULE_odataAlterAssignment = 232 - MDLParserRULE_odataAuthenticationClause = 233 - MDLParserRULE_odataAuthType = 234 - MDLParserRULE_publishEntityBlock = 235 - MDLParserRULE_exposeClause = 236 - MDLParserRULE_exposeMember = 237 - MDLParserRULE_exposeMemberOptions = 238 - MDLParserRULE_createExternalEntityStatement = 239 - MDLParserRULE_createNavigationStatement = 240 - MDLParserRULE_odataHeadersClause = 241 - MDLParserRULE_odataHeaderEntry = 242 - MDLParserRULE_createBusinessEventServiceStatement = 243 - MDLParserRULE_businessEventMessageDef = 244 - MDLParserRULE_businessEventAttrDef = 245 - MDLParserRULE_alterSettingsClause = 246 - MDLParserRULE_settingsSection = 247 - MDLParserRULE_settingsAssignment = 248 - MDLParserRULE_settingsValue = 249 - MDLParserRULE_dqlStatement = 250 - MDLParserRULE_showStatement = 251 - MDLParserRULE_showWidgetsFilter = 252 - MDLParserRULE_widgetTypeKeyword = 253 - MDLParserRULE_widgetCondition = 254 - MDLParserRULE_widgetPropertyAssignment = 255 - MDLParserRULE_widgetPropertyValue = 256 - MDLParserRULE_describeStatement = 257 - MDLParserRULE_catalogSelectQuery = 258 - MDLParserRULE_catalogJoinClause = 259 - MDLParserRULE_catalogTableName = 260 - MDLParserRULE_oqlQuery = 261 - MDLParserRULE_oqlQueryTerm = 262 - MDLParserRULE_selectClause = 263 - MDLParserRULE_selectList = 264 - MDLParserRULE_selectItem = 265 - MDLParserRULE_selectAlias = 266 - MDLParserRULE_fromClause = 267 - MDLParserRULE_tableReference = 268 - MDLParserRULE_joinClause = 269 - MDLParserRULE_associationPath = 270 - MDLParserRULE_joinType = 271 - MDLParserRULE_whereClause = 272 - MDLParserRULE_groupByClause = 273 - MDLParserRULE_havingClause = 274 - MDLParserRULE_orderByClause = 275 - MDLParserRULE_orderByList = 276 - MDLParserRULE_orderByItem = 277 - MDLParserRULE_groupByList = 278 - MDLParserRULE_limitOffsetClause = 279 - MDLParserRULE_utilityStatement = 280 - MDLParserRULE_searchStatement = 281 - MDLParserRULE_connectStatement = 282 - MDLParserRULE_disconnectStatement = 283 - MDLParserRULE_updateStatement = 284 - MDLParserRULE_checkStatement = 285 - MDLParserRULE_buildStatement = 286 - MDLParserRULE_executeScriptStatement = 287 - MDLParserRULE_executeRuntimeStatement = 288 - MDLParserRULE_lintStatement = 289 - MDLParserRULE_lintTarget = 290 - MDLParserRULE_lintFormat = 291 - MDLParserRULE_useSessionStatement = 292 - MDLParserRULE_sessionIdList = 293 - MDLParserRULE_sessionId = 294 - MDLParserRULE_introspectApiStatement = 295 - MDLParserRULE_debugStatement = 296 - MDLParserRULE_sqlStatement = 297 - MDLParserRULE_sqlPassthrough = 298 - MDLParserRULE_importStatement = 299 - MDLParserRULE_importMapping = 300 - MDLParserRULE_linkMapping = 301 - MDLParserRULE_helpStatement = 302 - MDLParserRULE_defineFragmentStatement = 303 - MDLParserRULE_expression = 304 - MDLParserRULE_orExpression = 305 - MDLParserRULE_andExpression = 306 - MDLParserRULE_notExpression = 307 - MDLParserRULE_comparisonExpression = 308 - MDLParserRULE_comparisonOperator = 309 - MDLParserRULE_additiveExpression = 310 - MDLParserRULE_multiplicativeExpression = 311 - MDLParserRULE_unaryExpression = 312 - MDLParserRULE_primaryExpression = 313 - MDLParserRULE_caseExpression = 314 - MDLParserRULE_castExpression = 315 - MDLParserRULE_castDataType = 316 - MDLParserRULE_aggregateFunction = 317 - MDLParserRULE_functionCall = 318 - MDLParserRULE_functionName = 319 - MDLParserRULE_argumentList = 320 - MDLParserRULE_atomicExpression = 321 - MDLParserRULE_expressionList = 322 - MDLParserRULE_qualifiedName = 323 - MDLParserRULE_identifierOrKeyword = 324 - MDLParserRULE_literal = 325 - MDLParserRULE_arrayLiteral = 326 - MDLParserRULE_booleanLiteral = 327 - MDLParserRULE_docComment = 328 - MDLParserRULE_annotation = 329 - MDLParserRULE_annotationName = 330 - MDLParserRULE_annotationParams = 331 - MDLParserRULE_annotationParam = 332 - MDLParserRULE_annotationValue = 333 - MDLParserRULE_commonNameKeyword = 334 - MDLParserRULE_keyword = 335 + MDLParserRULE_grantWorkflowAccessStatement = 31 + MDLParserRULE_revokeWorkflowAccessStatement = 32 + MDLParserRULE_grantODataServiceAccessStatement = 33 + MDLParserRULE_revokeODataServiceAccessStatement = 34 + MDLParserRULE_alterProjectSecurityStatement = 35 + MDLParserRULE_createDemoUserStatement = 36 + MDLParserRULE_dropDemoUserStatement = 37 + MDLParserRULE_updateSecurityStatement = 38 + MDLParserRULE_moduleRoleList = 39 + MDLParserRULE_entityAccessRightList = 40 + MDLParserRULE_entityAccessRight = 41 + MDLParserRULE_createEntityStatement = 42 + MDLParserRULE_generalizationClause = 43 + MDLParserRULE_entityBody = 44 + MDLParserRULE_entityOptions = 45 + MDLParserRULE_entityOption = 46 + MDLParserRULE_attributeDefinitionList = 47 + MDLParserRULE_attributeDefinition = 48 + MDLParserRULE_attributeName = 49 + MDLParserRULE_attributeConstraint = 50 + MDLParserRULE_dataType = 51 + MDLParserRULE_templateContext = 52 + MDLParserRULE_nonListDataType = 53 + MDLParserRULE_indexDefinition = 54 + MDLParserRULE_indexAttributeList = 55 + MDLParserRULE_indexAttribute = 56 + MDLParserRULE_indexColumnName = 57 + MDLParserRULE_createAssociationStatement = 58 + MDLParserRULE_associationOptions = 59 + MDLParserRULE_associationOption = 60 + MDLParserRULE_deleteBehavior = 61 + MDLParserRULE_alterEntityAction = 62 + MDLParserRULE_alterAssociationAction = 63 + MDLParserRULE_alterEnumerationAction = 64 + MDLParserRULE_alterNotebookAction = 65 + MDLParserRULE_createModuleStatement = 66 + MDLParserRULE_moduleOptions = 67 + MDLParserRULE_moduleOption = 68 + MDLParserRULE_createEnumerationStatement = 69 + MDLParserRULE_enumerationValueList = 70 + MDLParserRULE_enumerationValue = 71 + MDLParserRULE_enumValueName = 72 + MDLParserRULE_enumerationOptions = 73 + MDLParserRULE_enumerationOption = 74 + MDLParserRULE_createValidationRuleStatement = 75 + MDLParserRULE_validationRuleBody = 76 + MDLParserRULE_rangeConstraint = 77 + MDLParserRULE_attributeReference = 78 + MDLParserRULE_attributeReferenceList = 79 + MDLParserRULE_createMicroflowStatement = 80 + MDLParserRULE_createJavaActionStatement = 81 + MDLParserRULE_javaActionParameterList = 82 + MDLParserRULE_javaActionParameter = 83 + MDLParserRULE_javaActionReturnType = 84 + MDLParserRULE_javaActionExposedClause = 85 + MDLParserRULE_microflowParameterList = 86 + MDLParserRULE_microflowParameter = 87 + MDLParserRULE_parameterName = 88 + MDLParserRULE_microflowReturnType = 89 + MDLParserRULE_microflowOptions = 90 + MDLParserRULE_microflowOption = 91 + MDLParserRULE_microflowBody = 92 + MDLParserRULE_microflowStatement = 93 + MDLParserRULE_declareStatement = 94 + MDLParserRULE_setStatement = 95 + MDLParserRULE_createObjectStatement = 96 + MDLParserRULE_changeObjectStatement = 97 + MDLParserRULE_attributePath = 98 + MDLParserRULE_commitStatement = 99 + MDLParserRULE_deleteObjectStatement = 100 + MDLParserRULE_rollbackStatement = 101 + MDLParserRULE_retrieveStatement = 102 + MDLParserRULE_retrieveSource = 103 + MDLParserRULE_onErrorClause = 104 + MDLParserRULE_ifStatement = 105 + MDLParserRULE_loopStatement = 106 + MDLParserRULE_whileStatement = 107 + MDLParserRULE_continueStatement = 108 + MDLParserRULE_breakStatement = 109 + MDLParserRULE_returnStatement = 110 + MDLParserRULE_raiseErrorStatement = 111 + MDLParserRULE_logStatement = 112 + MDLParserRULE_logLevel = 113 + MDLParserRULE_templateParams = 114 + MDLParserRULE_templateParam = 115 + MDLParserRULE_logTemplateParams = 116 + MDLParserRULE_logTemplateParam = 117 + MDLParserRULE_callMicroflowStatement = 118 + MDLParserRULE_callJavaActionStatement = 119 + MDLParserRULE_executeDatabaseQueryStatement = 120 + MDLParserRULE_callExternalActionStatement = 121 + MDLParserRULE_callArgumentList = 122 + MDLParserRULE_callArgument = 123 + MDLParserRULE_showPageStatement = 124 + MDLParserRULE_showPageArgList = 125 + MDLParserRULE_showPageArg = 126 + MDLParserRULE_closePageStatement = 127 + MDLParserRULE_showHomePageStatement = 128 + MDLParserRULE_showMessageStatement = 129 + MDLParserRULE_throwStatement = 130 + MDLParserRULE_validationFeedbackStatement = 131 + MDLParserRULE_restCallStatement = 132 + MDLParserRULE_httpMethod = 133 + MDLParserRULE_restCallUrl = 134 + MDLParserRULE_restCallUrlParams = 135 + MDLParserRULE_restCallHeaderClause = 136 + MDLParserRULE_restCallAuthClause = 137 + MDLParserRULE_restCallBodyClause = 138 + MDLParserRULE_restCallTimeoutClause = 139 + MDLParserRULE_restCallReturnsClause = 140 + MDLParserRULE_listOperationStatement = 141 + MDLParserRULE_listOperation = 142 + MDLParserRULE_sortSpecList = 143 + MDLParserRULE_sortSpec = 144 + MDLParserRULE_aggregateListStatement = 145 + MDLParserRULE_listAggregateOperation = 146 + MDLParserRULE_createListStatement = 147 + MDLParserRULE_addToListStatement = 148 + MDLParserRULE_removeFromListStatement = 149 + MDLParserRULE_memberAssignmentList = 150 + MDLParserRULE_memberAssignment = 151 + MDLParserRULE_memberAttributeName = 152 + MDLParserRULE_changeList = 153 + MDLParserRULE_changeItem = 154 + MDLParserRULE_createPageStatement = 155 + MDLParserRULE_createSnippetStatement = 156 + MDLParserRULE_snippetOptions = 157 + MDLParserRULE_snippetOption = 158 + MDLParserRULE_pageParameterList = 159 + MDLParserRULE_pageParameter = 160 + MDLParserRULE_snippetParameterList = 161 + MDLParserRULE_snippetParameter = 162 + MDLParserRULE_variableDeclarationList = 163 + MDLParserRULE_variableDeclaration = 164 + MDLParserRULE_sortColumn = 165 + MDLParserRULE_xpathConstraint = 166 + MDLParserRULE_andOrXpath = 167 + MDLParserRULE_xpathExpr = 168 + MDLParserRULE_xpathAndExpr = 169 + MDLParserRULE_xpathNotExpr = 170 + MDLParserRULE_xpathComparisonExpr = 171 + MDLParserRULE_xpathValueExpr = 172 + MDLParserRULE_xpathPath = 173 + MDLParserRULE_xpathStep = 174 + MDLParserRULE_xpathStepValue = 175 + MDLParserRULE_xpathQualifiedName = 176 + MDLParserRULE_xpathWord = 177 + MDLParserRULE_xpathFunctionCall = 178 + MDLParserRULE_xpathFunctionName = 179 + MDLParserRULE_pageHeaderV3 = 180 + MDLParserRULE_pageHeaderPropertyV3 = 181 + MDLParserRULE_snippetHeaderV3 = 182 + MDLParserRULE_snippetHeaderPropertyV3 = 183 + MDLParserRULE_pageBodyV3 = 184 + MDLParserRULE_useFragmentRef = 185 + MDLParserRULE_widgetV3 = 186 + MDLParserRULE_widgetTypeV3 = 187 + MDLParserRULE_widgetPropertiesV3 = 188 + MDLParserRULE_widgetPropertyV3 = 189 + MDLParserRULE_filterTypeValue = 190 + MDLParserRULE_attributeListV3 = 191 + MDLParserRULE_dataSourceExprV3 = 192 + MDLParserRULE_actionExprV3 = 193 + MDLParserRULE_microflowArgsV3 = 194 + MDLParserRULE_microflowArgV3 = 195 + MDLParserRULE_attributePathV3 = 196 + MDLParserRULE_stringExprV3 = 197 + MDLParserRULE_paramListV3 = 198 + MDLParserRULE_paramAssignmentV3 = 199 + MDLParserRULE_renderModeV3 = 200 + MDLParserRULE_buttonStyleV3 = 201 + MDLParserRULE_desktopWidthV3 = 202 + MDLParserRULE_selectionModeV3 = 203 + MDLParserRULE_propertyValueV3 = 204 + MDLParserRULE_designPropertyListV3 = 205 + MDLParserRULE_designPropertyEntryV3 = 206 + MDLParserRULE_widgetBodyV3 = 207 + MDLParserRULE_createNotebookStatement = 208 + MDLParserRULE_notebookOptions = 209 + MDLParserRULE_notebookOption = 210 + MDLParserRULE_notebookPage = 211 + MDLParserRULE_createDatabaseConnectionStatement = 212 + MDLParserRULE_databaseConnectionOption = 213 + MDLParserRULE_databaseQuery = 214 + MDLParserRULE_databaseQueryMapping = 215 + MDLParserRULE_createConstantStatement = 216 + MDLParserRULE_constantOptions = 217 + MDLParserRULE_constantOption = 218 + MDLParserRULE_createRestClientStatement = 219 + MDLParserRULE_restClientOptions = 220 + MDLParserRULE_restClientOption = 221 + MDLParserRULE_restAuthentication = 222 + MDLParserRULE_restOperation = 223 + MDLParserRULE_restMethod = 224 + MDLParserRULE_restOperationOptions = 225 + MDLParserRULE_restOperationOption = 226 + MDLParserRULE_restResponse = 227 + MDLParserRULE_restParameter = 228 + MDLParserRULE_createIndexStatement = 229 + MDLParserRULE_createODataClientStatement = 230 + MDLParserRULE_createODataServiceStatement = 231 + MDLParserRULE_odataPropertyValue = 232 + MDLParserRULE_odataPropertyAssignment = 233 + MDLParserRULE_odataAlterAssignment = 234 + MDLParserRULE_odataAuthenticationClause = 235 + MDLParserRULE_odataAuthType = 236 + MDLParserRULE_publishEntityBlock = 237 + MDLParserRULE_exposeClause = 238 + MDLParserRULE_exposeMember = 239 + MDLParserRULE_exposeMemberOptions = 240 + MDLParserRULE_createExternalEntityStatement = 241 + MDLParserRULE_createNavigationStatement = 242 + MDLParserRULE_odataHeadersClause = 243 + MDLParserRULE_odataHeaderEntry = 244 + MDLParserRULE_createBusinessEventServiceStatement = 245 + MDLParserRULE_businessEventMessageDef = 246 + MDLParserRULE_businessEventAttrDef = 247 + MDLParserRULE_createWorkflowStatement = 248 + MDLParserRULE_workflowBody = 249 + MDLParserRULE_workflowActivityStmt = 250 + MDLParserRULE_workflowUserTaskStmt = 251 + MDLParserRULE_workflowBoundaryEventClause = 252 + MDLParserRULE_workflowUserTaskOutcome = 253 + MDLParserRULE_workflowCallMicroflowStmt = 254 + MDLParserRULE_workflowParameterMapping = 255 + MDLParserRULE_workflowCallWorkflowStmt = 256 + MDLParserRULE_workflowDecisionStmt = 257 + MDLParserRULE_workflowConditionOutcome = 258 + MDLParserRULE_workflowParallelSplitStmt = 259 + MDLParserRULE_workflowParallelPath = 260 + MDLParserRULE_workflowJumpToStmt = 261 + MDLParserRULE_workflowWaitForTimerStmt = 262 + MDLParserRULE_workflowWaitForNotificationStmt = 263 + MDLParserRULE_workflowAnnotationStmt = 264 + MDLParserRULE_alterSettingsClause = 265 + MDLParserRULE_settingsSection = 266 + MDLParserRULE_settingsAssignment = 267 + MDLParserRULE_settingsValue = 268 + MDLParserRULE_dqlStatement = 269 + MDLParserRULE_showStatement = 270 + MDLParserRULE_showWidgetsFilter = 271 + MDLParserRULE_widgetTypeKeyword = 272 + MDLParserRULE_widgetCondition = 273 + MDLParserRULE_widgetPropertyAssignment = 274 + MDLParserRULE_widgetPropertyValue = 275 + MDLParserRULE_describeStatement = 276 + MDLParserRULE_catalogSelectQuery = 277 + MDLParserRULE_catalogJoinClause = 278 + MDLParserRULE_catalogTableName = 279 + MDLParserRULE_oqlQuery = 280 + MDLParserRULE_oqlQueryTerm = 281 + MDLParserRULE_selectClause = 282 + MDLParserRULE_selectList = 283 + MDLParserRULE_selectItem = 284 + MDLParserRULE_selectAlias = 285 + MDLParserRULE_fromClause = 286 + MDLParserRULE_tableReference = 287 + MDLParserRULE_joinClause = 288 + MDLParserRULE_associationPath = 289 + MDLParserRULE_joinType = 290 + MDLParserRULE_whereClause = 291 + MDLParserRULE_groupByClause = 292 + MDLParserRULE_havingClause = 293 + MDLParserRULE_orderByClause = 294 + MDLParserRULE_orderByList = 295 + MDLParserRULE_orderByItem = 296 + MDLParserRULE_groupByList = 297 + MDLParserRULE_limitOffsetClause = 298 + MDLParserRULE_utilityStatement = 299 + MDLParserRULE_searchStatement = 300 + MDLParserRULE_connectStatement = 301 + MDLParserRULE_disconnectStatement = 302 + MDLParserRULE_updateStatement = 303 + MDLParserRULE_checkStatement = 304 + MDLParserRULE_buildStatement = 305 + MDLParserRULE_executeScriptStatement = 306 + MDLParserRULE_executeRuntimeStatement = 307 + MDLParserRULE_lintStatement = 308 + MDLParserRULE_lintTarget = 309 + MDLParserRULE_lintFormat = 310 + MDLParserRULE_useSessionStatement = 311 + MDLParserRULE_sessionIdList = 312 + MDLParserRULE_sessionId = 313 + MDLParserRULE_introspectApiStatement = 314 + MDLParserRULE_debugStatement = 315 + MDLParserRULE_sqlStatement = 316 + MDLParserRULE_sqlPassthrough = 317 + MDLParserRULE_importStatement = 318 + MDLParserRULE_importMapping = 319 + MDLParserRULE_linkMapping = 320 + MDLParserRULE_helpStatement = 321 + MDLParserRULE_defineFragmentStatement = 322 + MDLParserRULE_expression = 323 + MDLParserRULE_orExpression = 324 + MDLParserRULE_andExpression = 325 + MDLParserRULE_notExpression = 326 + MDLParserRULE_comparisonExpression = 327 + MDLParserRULE_comparisonOperator = 328 + MDLParserRULE_additiveExpression = 329 + MDLParserRULE_multiplicativeExpression = 330 + MDLParserRULE_unaryExpression = 331 + MDLParserRULE_primaryExpression = 332 + MDLParserRULE_caseExpression = 333 + MDLParserRULE_castExpression = 334 + MDLParserRULE_castDataType = 335 + MDLParserRULE_aggregateFunction = 336 + MDLParserRULE_functionCall = 337 + MDLParserRULE_functionName = 338 + MDLParserRULE_argumentList = 339 + MDLParserRULE_atomicExpression = 340 + MDLParserRULE_expressionList = 341 + MDLParserRULE_qualifiedName = 342 + MDLParserRULE_identifierOrKeyword = 343 + MDLParserRULE_literal = 344 + MDLParserRULE_arrayLiteral = 345 + MDLParserRULE_booleanLiteral = 346 + MDLParserRULE_docComment = 347 + MDLParserRULE_annotation = 348 + MDLParserRULE_annotationName = 349 + MDLParserRULE_annotationParams = 350 + MDLParserRULE_annotationParam = 351 + MDLParserRULE_annotationValue = 352 + MDLParserRULE_commonNameKeyword = 353 + MDLParserRULE_keyword = 354 ) // IProgramContext is an interface to support dynamic dispatch. @@ -3962,20 +4241,20 @@ func (p *MDLParser) Program() (localctx IProgramContext) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(675) + p.SetState(713) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&108086391060955140) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&127) != 0) || _la == MDLParserSEARCH || ((int64((_la-347)) & ^0x3f) == 0 && ((int64(1)<<(_la-347))&3264712015873) != 0) || ((int64((_la-418)) & ^0x3f) == 0 && ((int64(1)<<(_la-418))&9007199254790145) != 0) || _la == MDLParserIDENTIFIER { + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&108086391060955140) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&127) != 0) || _la == MDLParserSEARCH || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&3264712015873) != 0) || ((int64((_la-419)) & ^0x3f) == 0 && ((int64(1)<<(_la-419))&49153) != 0) || _la == MDLParserAT || _la == MDLParserIDENTIFIER { { - p.SetState(672) + p.SetState(710) p.Statement() } - p.SetState(677) + p.SetState(715) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -3983,7 +4262,7 @@ func (p *MDLParser) Program() (localctx IProgramContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(678) + p.SetState(716) p.Match(MDLParserEOF) if p.HasError() { // Recognition error - abort rule @@ -4153,19 +4432,19 @@ func (p *MDLParser) Statement() (localctx IStatementContext) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(681) + p.SetState(719) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext()) == 1 { { - p.SetState(680) + p.SetState(718) p.DocComment() } } else if p.HasError() { // JIM goto errorExit } - p.SetState(686) + p.SetState(724) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4174,26 +4453,26 @@ func (p *MDLParser) Statement() (localctx IStatementContext) { switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) { case 1: { - p.SetState(683) + p.SetState(721) p.DdlStatement() } case 2: { - p.SetState(684) + p.SetState(722) p.DqlStatement() } case 3: { - p.SetState(685) + p.SetState(723) p.UtilityStatement() } case antlr.ATNInvalidAltNumber: goto errorExit } - p.SetState(689) + p.SetState(727) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4202,7 +4481,7 @@ func (p *MDLParser) Statement() (localctx IStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(688) + p.SetState(726) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -4211,7 +4490,7 @@ func (p *MDLParser) Statement() (localctx IStatementContext) { } } - p.SetState(692) + p.SetState(730) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4220,7 +4499,7 @@ func (p *MDLParser) Statement() (localctx IStatementContext) { if _la == MDLParserSLASH { { - p.SetState(691) + p.SetState(729) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule @@ -4430,7 +4709,7 @@ func (s *DdlStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DdlStatement() (localctx IDdlStatementContext) { localctx = NewDdlStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 4, MDLParserRULE_ddlStatement) - p.SetState(701) + p.SetState(739) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4440,49 +4719,49 @@ func (p *MDLParser) DdlStatement() (localctx IDdlStatementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(694) + p.SetState(732) p.CreateStatement() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(695) + p.SetState(733) p.AlterStatement() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(696) + p.SetState(734) p.DropStatement() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(697) + p.SetState(735) p.RenameStatement() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(698) + p.SetState(736) p.MoveStatement() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(699) + p.SetState(737) p.UpdateWidgetsStatement() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(700) + p.SetState(738) p.SecurityStatement() } @@ -4738,7 +5017,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo p.EnterOuterAlt(localctx, 1) { - p.SetState(703) + p.SetState(741) p.Match(MDLParserUPDATE) if p.HasError() { // Recognition error - abort rule @@ -4746,7 +5025,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } { - p.SetState(704) + p.SetState(742) p.Match(MDLParserWIDGETS) if p.HasError() { // Recognition error - abort rule @@ -4754,7 +5033,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } { - p.SetState(705) + p.SetState(743) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -4762,10 +5041,10 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } { - p.SetState(706) + p.SetState(744) p.WidgetPropertyAssignment() } - p.SetState(711) + p.SetState(749) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4774,7 +5053,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo for _la == MDLParserCOMMA { { - p.SetState(707) + p.SetState(745) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -4782,11 +5061,11 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } { - p.SetState(708) + p.SetState(746) p.WidgetPropertyAssignment() } - p.SetState(713) + p.SetState(751) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4794,7 +5073,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo _la = p.GetTokenStream().LA(1) } { - p.SetState(714) + p.SetState(752) p.Match(MDLParserWHERE) if p.HasError() { // Recognition error - abort rule @@ -4802,10 +5081,10 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } { - p.SetState(715) + p.SetState(753) p.WidgetCondition() } - p.SetState(720) + p.SetState(758) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4814,7 +5093,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo for _la == MDLParserAND { { - p.SetState(716) + p.SetState(754) p.Match(MDLParserAND) if p.HasError() { // Recognition error - abort rule @@ -4822,18 +5101,18 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } { - p.SetState(717) + p.SetState(755) p.WidgetCondition() } - p.SetState(722) + p.SetState(760) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(728) + p.SetState(766) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4842,14 +5121,14 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo if _la == MDLParserIN { { - p.SetState(723) + p.SetState(761) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(726) + p.SetState(764) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4858,13 +5137,13 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 8, p.GetParserRuleContext()) { case 1: { - p.SetState(724) + p.SetState(762) p.QualifiedName() } case 2: { - p.SetState(725) + p.SetState(763) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -4877,7 +5156,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } - p.SetState(732) + p.SetState(770) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4886,7 +5165,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo if _la == MDLParserDRY { { - p.SetState(730) + p.SetState(768) p.Match(MDLParserDRY) if p.HasError() { // Recognition error - abort rule @@ -4894,7 +5173,7 @@ func (p *MDLParser) UpdateWidgetsStatement() (localctx IUpdateWidgetsStatementCo } } { - p.SetState(731) + p.SetState(769) p.Match(MDLParserRUN) if p.HasError() { // Recognition error - abort rule @@ -4945,6 +5224,7 @@ type ICreateStatementContext interface { CreateExternalEntityStatement() ICreateExternalEntityStatementContext CreateNavigationStatement() ICreateNavigationStatementContext CreateBusinessEventServiceStatement() ICreateBusinessEventServiceStatementContext + CreateWorkflowStatement() ICreateWorkflowStatementContext DocComment() IDocCommentContext AllAnnotation() []IAnnotationContext Annotation(i int) IAnnotationContext @@ -5296,6 +5576,22 @@ func (s *CreateStatementContext) CreateBusinessEventServiceStatement() ICreateBu return t.(ICreateBusinessEventServiceStatementContext) } +func (s *CreateStatementContext) CreateWorkflowStatement() ICreateWorkflowStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateWorkflowStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateWorkflowStatementContext) +} + func (s *CreateStatementContext) DocComment() IDocCommentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { @@ -5391,7 +5687,7 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(735) + p.SetState(773) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5400,12 +5696,12 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { if _la == MDLParserDOC_COMMENT { { - p.SetState(734) + p.SetState(772) p.DocComment() } } - p.SetState(740) + p.SetState(778) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5414,11 +5710,11 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { for _la == MDLParserAT { { - p.SetState(737) + p.SetState(775) p.Annotation() } - p.SetState(742) + p.SetState(780) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5426,14 +5722,14 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(743) + p.SetState(781) p.Match(MDLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(746) + p.SetState(784) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5442,7 +5738,7 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { if _la == MDLParserOR { { - p.SetState(744) + p.SetState(782) p.Match(MDLParserOR) if p.HasError() { // Recognition error - abort rule @@ -5450,7 +5746,7 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { } } { - p.SetState(745) + p.SetState(783) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserMODIFY || _la == MDLParserREPLACE) { @@ -5462,7 +5758,7 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { } } - p.SetState(767) + p.SetState(806) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5471,118 +5767,124 @@ func (p *MDLParser) CreateStatement() (localctx ICreateStatementContext) { switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) { case 1: { - p.SetState(748) + p.SetState(786) p.CreateEntityStatement() } case 2: { - p.SetState(749) + p.SetState(787) p.CreateAssociationStatement() } case 3: { - p.SetState(750) + p.SetState(788) p.CreateModuleStatement() } case 4: { - p.SetState(751) + p.SetState(789) p.CreateMicroflowStatement() } case 5: { - p.SetState(752) + p.SetState(790) p.CreateJavaActionStatement() } case 6: { - p.SetState(753) + p.SetState(791) p.CreatePageStatement() } case 7: { - p.SetState(754) + p.SetState(792) p.CreateSnippetStatement() } case 8: { - p.SetState(755) + p.SetState(793) p.CreateEnumerationStatement() } case 9: { - p.SetState(756) + p.SetState(794) p.CreateValidationRuleStatement() } case 10: { - p.SetState(757) + p.SetState(795) p.CreateNotebookStatement() } case 11: { - p.SetState(758) + p.SetState(796) p.CreateDatabaseConnectionStatement() } case 12: { - p.SetState(759) + p.SetState(797) p.CreateConstantStatement() } case 13: { - p.SetState(760) + p.SetState(798) p.CreateRestClientStatement() } case 14: { - p.SetState(761) + p.SetState(799) p.CreateIndexStatement() } case 15: { - p.SetState(762) + p.SetState(800) p.CreateODataClientStatement() } case 16: { - p.SetState(763) + p.SetState(801) p.CreateODataServiceStatement() } case 17: { - p.SetState(764) + p.SetState(802) p.CreateExternalEntityStatement() } case 18: { - p.SetState(765) + p.SetState(803) p.CreateNavigationStatement() } case 19: { - p.SetState(766) + p.SetState(804) p.CreateBusinessEventServiceStatement() } + case 20: + { + p.SetState(805) + p.CreateWorkflowStatement() + } + case antlr.ATNInvalidAltNumber: goto errorExit } @@ -6107,7 +6409,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { var _alt int - p.SetState(864) + p.SetState(903) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6117,7 +6419,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(769) + p.SetState(808) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6125,7 +6427,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(770) + p.SetState(809) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -6133,10 +6435,10 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(771) + p.SetState(810) p.QualifiedName() } - p.SetState(773) + p.SetState(812) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6146,7 +6448,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { switch _alt { case 1: { - p.SetState(772) + p.SetState(811) p.AlterEntityAction() } @@ -6155,7 +6457,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { goto errorExit } - p.SetState(775) + p.SetState(814) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) if p.HasError() { @@ -6166,7 +6468,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(777) + p.SetState(816) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6174,7 +6476,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(778) + p.SetState(817) p.Match(MDLParserASSOCIATION) if p.HasError() { // Recognition error - abort rule @@ -6182,10 +6484,10 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(779) + p.SetState(818) p.QualifiedName() } - p.SetState(781) + p.SetState(820) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6194,11 +6496,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { for ok := true; ok; ok = _la == MDLParserSET { { - p.SetState(780) + p.SetState(819) p.AlterAssociationAction() } - p.SetState(783) + p.SetState(822) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6209,7 +6511,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(785) + p.SetState(824) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6217,7 +6519,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(786) + p.SetState(825) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -6225,10 +6527,10 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(787) + p.SetState(826) p.QualifiedName() } - p.SetState(789) + p.SetState(828) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6238,7 +6540,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { switch _alt { case 1: { - p.SetState(788) + p.SetState(827) p.AlterEnumerationAction() } @@ -6247,7 +6549,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { goto errorExit } - p.SetState(791) + p.SetState(830) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) if p.HasError() { @@ -6258,7 +6560,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(793) + p.SetState(832) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6266,7 +6568,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(794) + p.SetState(833) p.Match(MDLParserNOTEBOOK) if p.HasError() { // Recognition error - abort rule @@ -6274,10 +6576,10 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(795) + p.SetState(834) p.QualifiedName() } - p.SetState(797) + p.SetState(836) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6287,7 +6589,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { switch _alt { case 1: { - p.SetState(796) + p.SetState(835) p.AlterNotebookAction() } @@ -6296,7 +6598,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { goto errorExit } - p.SetState(799) + p.SetState(838) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) if p.HasError() { @@ -6307,7 +6609,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(801) + p.SetState(840) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6315,7 +6617,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(802) + p.SetState(841) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -6323,7 +6625,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(803) + p.SetState(842) p.Match(MDLParserCLIENT) if p.HasError() { // Recognition error - abort rule @@ -6331,11 +6633,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(804) + p.SetState(843) p.QualifiedName() } { - p.SetState(805) + p.SetState(844) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -6343,10 +6645,10 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(806) + p.SetState(845) p.OdataAlterAssignment() } - p.SetState(811) + p.SetState(850) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6355,7 +6657,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { for _la == MDLParserCOMMA { { - p.SetState(807) + p.SetState(846) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -6363,11 +6665,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(808) + p.SetState(847) p.OdataAlterAssignment() } - p.SetState(813) + p.SetState(852) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6378,7 +6680,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(814) + p.SetState(853) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6386,7 +6688,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(815) + p.SetState(854) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -6394,7 +6696,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(816) + p.SetState(855) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -6402,11 +6704,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(817) + p.SetState(856) p.QualifiedName() } { - p.SetState(818) + p.SetState(857) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -6414,10 +6716,10 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(819) + p.SetState(858) p.OdataAlterAssignment() } - p.SetState(824) + p.SetState(863) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6426,7 +6728,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { for _la == MDLParserCOMMA { { - p.SetState(820) + p.SetState(859) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -6434,11 +6736,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(821) + p.SetState(860) p.OdataAlterAssignment() } - p.SetState(826) + p.SetState(865) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6449,7 +6751,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(827) + p.SetState(866) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6457,7 +6759,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(828) + p.SetState(867) p.Match(MDLParserSTYLING) if p.HasError() { // Recognition error - abort rule @@ -6465,7 +6767,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(829) + p.SetState(868) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -6473,7 +6775,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(830) + p.SetState(869) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserPAGE || _la == MDLParserSNIPPET) { @@ -6484,11 +6786,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(831) + p.SetState(870) p.QualifiedName() } { - p.SetState(832) + p.SetState(871) p.Match(MDLParserWIDGET) if p.HasError() { // Recognition error - abort rule @@ -6496,14 +6798,14 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(833) + p.SetState(872) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(835) + p.SetState(874) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6512,11 +6814,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { for ok := true; ok; ok = _la == MDLParserSET || _la == MDLParserCLEAR { { - p.SetState(834) + p.SetState(873) p.AlterStylingAction() } - p.SetState(837) + p.SetState(876) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6527,7 +6829,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(839) + p.SetState(878) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6535,7 +6837,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(840) + p.SetState(879) p.Match(MDLParserSETTINGS) if p.HasError() { // Recognition error - abort rule @@ -6543,14 +6845,14 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(841) + p.SetState(880) p.AlterSettingsClause() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(842) + p.SetState(881) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6558,7 +6860,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(843) + p.SetState(882) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -6566,18 +6868,18 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(844) + p.SetState(883) p.QualifiedName() } { - p.SetState(845) + p.SetState(884) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(847) + p.SetState(886) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6586,11 +6888,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { for ok := true; ok; ok = _la == MDLParserDROP || _la == MDLParserSET || _la == MDLParserINSERT || _la == MDLParserREPLACE { { - p.SetState(846) + p.SetState(885) p.AlterPageOperation() } - p.SetState(849) + p.SetState(888) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6598,7 +6900,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(851) + p.SetState(890) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -6609,7 +6911,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(853) + p.SetState(892) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -6617,7 +6919,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(854) + p.SetState(893) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -6625,18 +6927,18 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { } } { - p.SetState(855) + p.SetState(894) p.QualifiedName() } { - p.SetState(856) + p.SetState(895) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(858) + p.SetState(897) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6645,11 +6947,11 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { for ok := true; ok; ok = _la == MDLParserDROP || _la == MDLParserSET || _la == MDLParserINSERT || _la == MDLParserREPLACE { { - p.SetState(857) + p.SetState(896) p.AlterPageOperation() } - p.SetState(860) + p.SetState(899) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6657,7 +6959,7 @@ func (p *MDLParser) AlterStatement() (localctx IAlterStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(862) + p.SetState(901) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -6825,7 +7127,7 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { p.EnterRule(localctx, 12, MDLParserRULE_alterStylingAction) var _la int - p.SetState(878) + p.SetState(917) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6835,7 +7137,7 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { case MDLParserSET: p.EnterOuterAlt(localctx, 1) { - p.SetState(866) + p.SetState(905) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -6843,10 +7145,10 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { } } { - p.SetState(867) + p.SetState(906) p.AlterStylingAssignment() } - p.SetState(872) + p.SetState(911) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6855,7 +7157,7 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { for _la == MDLParserCOMMA { { - p.SetState(868) + p.SetState(907) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -6863,11 +7165,11 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { } } { - p.SetState(869) + p.SetState(908) p.AlterStylingAssignment() } - p.SetState(874) + p.SetState(913) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6878,7 +7180,7 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { case MDLParserCLEAR: p.EnterOuterAlt(localctx, 2) { - p.SetState(875) + p.SetState(914) p.Match(MDLParserCLEAR) if p.HasError() { // Recognition error - abort rule @@ -6886,7 +7188,7 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { } } { - p.SetState(876) + p.SetState(915) p.Match(MDLParserDESIGN) if p.HasError() { // Recognition error - abort rule @@ -6894,7 +7196,7 @@ func (p *MDLParser) AlterStylingAction() (localctx IAlterStylingActionContext) { } } { - p.SetState(877) + p.SetState(916) p.Match(MDLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule @@ -7023,7 +7325,7 @@ func (s *AlterStylingAssignmentContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentContext) { localctx = NewAlterStylingAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 14, MDLParserRULE_alterStylingAssignment) - p.SetState(895) + p.SetState(934) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7033,7 +7335,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(880) + p.SetState(919) p.Match(MDLParserCLASS) if p.HasError() { // Recognition error - abort rule @@ -7041,7 +7343,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(881) + p.SetState(920) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -7049,7 +7351,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(882) + p.SetState(921) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -7060,7 +7362,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(883) + p.SetState(922) p.Match(MDLParserSTYLE) if p.HasError() { // Recognition error - abort rule @@ -7068,7 +7370,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(884) + p.SetState(923) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -7076,7 +7378,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(885) + p.SetState(924) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -7087,7 +7389,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(886) + p.SetState(925) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -7095,7 +7397,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(887) + p.SetState(926) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -7103,7 +7405,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(888) + p.SetState(927) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -7114,7 +7416,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(889) + p.SetState(928) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -7122,7 +7424,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(890) + p.SetState(929) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -7130,7 +7432,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(891) + p.SetState(930) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -7141,7 +7443,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(892) + p.SetState(931) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -7149,7 +7451,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(893) + p.SetState(932) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -7157,7 +7459,7 @@ func (p *MDLParser) AlterStylingAssignment() (localctx IAlterStylingAssignmentCo } } { - p.SetState(894) + p.SetState(933) p.Match(MDLParserOFF) if p.HasError() { // Recognition error - abort rule @@ -7325,7 +7627,7 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { p.EnterRule(localctx, 16, MDLParserRULE_alterPageOperation) var _la int - p.SetState(913) + p.SetState(952) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7335,10 +7637,10 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { case MDLParserSET: p.EnterOuterAlt(localctx, 1) { - p.SetState(897) + p.SetState(936) p.AlterPageSet() } - p.SetState(899) + p.SetState(938) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7347,7 +7649,7 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { if _la == MDLParserSEMICOLON { { - p.SetState(898) + p.SetState(937) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -7360,10 +7662,10 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { case MDLParserINSERT: p.EnterOuterAlt(localctx, 2) { - p.SetState(901) + p.SetState(940) p.AlterPageInsert() } - p.SetState(903) + p.SetState(942) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7372,7 +7674,7 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { if _la == MDLParserSEMICOLON { { - p.SetState(902) + p.SetState(941) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -7385,10 +7687,10 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { case MDLParserDROP: p.EnterOuterAlt(localctx, 3) { - p.SetState(905) + p.SetState(944) p.AlterPageDrop() } - p.SetState(907) + p.SetState(946) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7397,7 +7699,7 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { if _la == MDLParserSEMICOLON { { - p.SetState(906) + p.SetState(945) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -7410,10 +7712,10 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { case MDLParserREPLACE: p.EnterOuterAlt(localctx, 4) { - p.SetState(909) + p.SetState(948) p.AlterPageReplace() } - p.SetState(911) + p.SetState(950) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7422,7 +7724,7 @@ func (p *MDLParser) AlterPageOperation() (localctx IAlterPageOperationContext) { if _la == MDLParserSEMICOLON { { - p.SetState(910) + p.SetState(949) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -7610,7 +7912,7 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { p.EnterRule(localctx, 18, MDLParserRULE_alterPageSet) var _la int - p.SetState(936) + p.SetState(975) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7620,7 +7922,7 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(915) + p.SetState(954) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -7628,11 +7930,11 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(916) + p.SetState(955) p.AlterPageAssignment() } { - p.SetState(917) + p.SetState(956) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -7640,14 +7942,14 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(918) + p.SetState(957) p.IdentifierOrKeyword() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(920) + p.SetState(959) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -7655,7 +7957,7 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(921) + p.SetState(960) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -7663,10 +7965,10 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(922) + p.SetState(961) p.AlterPageAssignment() } - p.SetState(927) + p.SetState(966) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7675,7 +7977,7 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { for _la == MDLParserCOMMA { { - p.SetState(923) + p.SetState(962) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -7683,11 +7985,11 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(924) + p.SetState(963) p.AlterPageAssignment() } - p.SetState(929) + p.SetState(968) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7695,7 +7997,7 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(930) + p.SetState(969) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -7703,7 +8005,7 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(931) + p.SetState(970) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -7711,14 +8013,14 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(932) + p.SetState(971) p.IdentifierOrKeyword() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(934) + p.SetState(973) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -7726,7 +8028,7 @@ func (p *MDLParser) AlterPageSet() (localctx IAlterPageSetContext) { } } { - p.SetState(935) + p.SetState(974) p.AlterPageAssignment() } @@ -7859,21 +8161,21 @@ func (s *AlterPageAssignmentContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) AlterPageAssignment() (localctx IAlterPageAssignmentContext) { localctx = NewAlterPageAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 20, MDLParserRULE_alterPageAssignment) - p.SetState(945) + p.SetState(984) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(938) + p.SetState(977) p.IdentifierOrKeyword() } { - p.SetState(939) + p.SetState(978) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -7881,14 +8183,14 @@ func (p *MDLParser) AlterPageAssignment() (localctx IAlterPageAssignmentContext) } } { - p.SetState(940) + p.SetState(979) p.PropertyValueV3() } case MDLParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 2) { - p.SetState(942) + p.SetState(981) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -7896,7 +8198,7 @@ func (p *MDLParser) AlterPageAssignment() (localctx IAlterPageAssignmentContext) } } { - p.SetState(943) + p.SetState(982) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -7904,7 +8206,7 @@ func (p *MDLParser) AlterPageAssignment() (localctx IAlterPageAssignmentContext) } } { - p.SetState(944) + p.SetState(983) p.PropertyValueV3() } @@ -8053,7 +8355,7 @@ func (s *AlterPageInsertContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { localctx = NewAlterPageInsertContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 22, MDLParserRULE_alterPageInsert) - p.SetState(961) + p.SetState(1000) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8063,7 +8365,7 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(947) + p.SetState(986) p.Match(MDLParserINSERT) if p.HasError() { // Recognition error - abort rule @@ -8071,7 +8373,7 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { } } { - p.SetState(948) + p.SetState(987) p.Match(MDLParserAFTER) if p.HasError() { // Recognition error - abort rule @@ -8079,11 +8381,11 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { } } { - p.SetState(949) + p.SetState(988) p.IdentifierOrKeyword() } { - p.SetState(950) + p.SetState(989) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -8091,11 +8393,11 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { } } { - p.SetState(951) + p.SetState(990) p.PageBodyV3() } { - p.SetState(952) + p.SetState(991) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -8106,7 +8408,7 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(954) + p.SetState(993) p.Match(MDLParserINSERT) if p.HasError() { // Recognition error - abort rule @@ -8114,7 +8416,7 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { } } { - p.SetState(955) + p.SetState(994) p.Match(MDLParserBEFORE) if p.HasError() { // Recognition error - abort rule @@ -8122,11 +8424,11 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { } } { - p.SetState(956) + p.SetState(995) p.IdentifierOrKeyword() } { - p.SetState(957) + p.SetState(996) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -8134,11 +8436,11 @@ func (p *MDLParser) AlterPageInsert() (localctx IAlterPageInsertContext) { } } { - p.SetState(958) + p.SetState(997) p.PageBodyV3() } { - p.SetState(959) + p.SetState(998) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -8298,7 +8600,7 @@ func (p *MDLParser) AlterPageDrop() (localctx IAlterPageDropContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(963) + p.SetState(1002) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -8306,7 +8608,7 @@ func (p *MDLParser) AlterPageDrop() (localctx IAlterPageDropContext) { } } { - p.SetState(964) + p.SetState(1003) p.Match(MDLParserWIDGET) if p.HasError() { // Recognition error - abort rule @@ -8314,10 +8616,10 @@ func (p *MDLParser) AlterPageDrop() (localctx IAlterPageDropContext) { } } { - p.SetState(965) + p.SetState(1004) p.IdentifierOrKeyword() } - p.SetState(970) + p.SetState(1009) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8326,7 +8628,7 @@ func (p *MDLParser) AlterPageDrop() (localctx IAlterPageDropContext) { for _la == MDLParserCOMMA { { - p.SetState(966) + p.SetState(1005) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -8334,11 +8636,11 @@ func (p *MDLParser) AlterPageDrop() (localctx IAlterPageDropContext) { } } { - p.SetState(967) + p.SetState(1006) p.IdentifierOrKeyword() } - p.SetState(972) + p.SetState(1011) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8483,7 +8785,7 @@ func (p *MDLParser) AlterPageReplace() (localctx IAlterPageReplaceContext) { p.EnterRule(localctx, 26, MDLParserRULE_alterPageReplace) p.EnterOuterAlt(localctx, 1) { - p.SetState(973) + p.SetState(1012) p.Match(MDLParserREPLACE) if p.HasError() { // Recognition error - abort rule @@ -8491,11 +8793,11 @@ func (p *MDLParser) AlterPageReplace() (localctx IAlterPageReplaceContext) { } } { - p.SetState(974) + p.SetState(1013) p.IdentifierOrKeyword() } { - p.SetState(975) + p.SetState(1014) p.Match(MDLParserWITH) if p.HasError() { // Recognition error - abort rule @@ -8503,7 +8805,7 @@ func (p *MDLParser) AlterPageReplace() (localctx IAlterPageReplaceContext) { } } { - p.SetState(976) + p.SetState(1015) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -8511,11 +8813,11 @@ func (p *MDLParser) AlterPageReplace() (localctx IAlterPageReplaceContext) { } } { - p.SetState(977) + p.SetState(1016) p.PageBodyV3() } { - p.SetState(978) + p.SetState(1017) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -8742,7 +9044,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { p.EnterRule(localctx, 28, MDLParserRULE_navigationClause) var _la int - p.SetState(1003) + p.SetState(1042) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8752,7 +9054,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { case MDLParserHOME: p.EnterOuterAlt(localctx, 1) { - p.SetState(980) + p.SetState(1019) p.Match(MDLParserHOME) if p.HasError() { // Recognition error - abort rule @@ -8760,7 +9062,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(981) + p.SetState(1020) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserMICROFLOW || _la == MDLParserPAGE) { @@ -8771,10 +9073,10 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(982) + p.SetState(1021) p.QualifiedName() } - p.SetState(985) + p.SetState(1024) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8783,7 +9085,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { if _la == MDLParserFOR { { - p.SetState(983) + p.SetState(1022) p.Match(MDLParserFOR) if p.HasError() { // Recognition error - abort rule @@ -8791,7 +9093,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(984) + p.SetState(1023) p.QualifiedName() } @@ -8800,7 +9102,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { case MDLParserLOGIN: p.EnterOuterAlt(localctx, 2) { - p.SetState(987) + p.SetState(1026) p.Match(MDLParserLOGIN) if p.HasError() { // Recognition error - abort rule @@ -8808,7 +9110,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(988) + p.SetState(1027) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -8816,14 +9118,14 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(989) + p.SetState(1028) p.QualifiedName() } case MDLParserNOT: p.EnterOuterAlt(localctx, 3) { - p.SetState(990) + p.SetState(1029) p.Match(MDLParserNOT) if p.HasError() { // Recognition error - abort rule @@ -8831,7 +9133,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(991) + p.SetState(1030) p.Match(MDLParserFOUND) if p.HasError() { // Recognition error - abort rule @@ -8839,7 +9141,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(992) + p.SetState(1031) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -8847,14 +9149,14 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(993) + p.SetState(1032) p.QualifiedName() } case MDLParserMENU_KW: p.EnterOuterAlt(localctx, 4) { - p.SetState(994) + p.SetState(1033) p.Match(MDLParserMENU_KW) if p.HasError() { // Recognition error - abort rule @@ -8862,14 +9164,14 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { } } { - p.SetState(995) + p.SetState(1034) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(999) + p.SetState(1038) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8878,11 +9180,11 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { for _la == MDLParserMENU_KW { { - p.SetState(996) + p.SetState(1035) p.NavMenuItemDef() } - p.SetState(1001) + p.SetState(1040) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8890,7 +9192,7 @@ func (p *MDLParser) NavigationClause() (localctx INavigationClauseContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1002) + p.SetState(1041) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -9086,7 +9388,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { p.EnterRule(localctx, 30, MDLParserRULE_navMenuItemDef) var _la int - p.SetState(1030) + p.SetState(1069) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9096,7 +9398,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1005) + p.SetState(1044) p.Match(MDLParserMENU_KW) if p.HasError() { // Recognition error - abort rule @@ -9104,7 +9406,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { } } { - p.SetState(1006) + p.SetState(1045) p.Match(MDLParserITEM) if p.HasError() { // Recognition error - abort rule @@ -9112,14 +9414,14 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { } } { - p.SetState(1007) + p.SetState(1046) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1012) + p.SetState(1051) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9127,7 +9429,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { switch p.GetTokenStream().LA(1) { case MDLParserPAGE: { - p.SetState(1008) + p.SetState(1047) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -9135,13 +9437,13 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { } } { - p.SetState(1009) + p.SetState(1048) p.QualifiedName() } case MDLParserMICROFLOW: { - p.SetState(1010) + p.SetState(1049) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -9149,7 +9451,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { } } { - p.SetState(1011) + p.SetState(1050) p.QualifiedName() } @@ -9157,7 +9459,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { default: } - p.SetState(1015) + p.SetState(1054) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9166,7 +9468,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { if _la == MDLParserSEMICOLON { { - p.SetState(1014) + p.SetState(1053) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -9179,7 +9481,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1017) + p.SetState(1056) p.Match(MDLParserMENU_KW) if p.HasError() { // Recognition error - abort rule @@ -9187,7 +9489,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { } } { - p.SetState(1018) + p.SetState(1057) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -9195,14 +9497,14 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { } } { - p.SetState(1019) + p.SetState(1058) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1023) + p.SetState(1062) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9211,11 +9513,11 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { for _la == MDLParserMENU_KW { { - p.SetState(1020) + p.SetState(1059) p.NavMenuItemDef() } - p.SetState(1025) + p.SetState(1064) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9223,14 +9525,14 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1026) + p.SetState(1065) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1028) + p.SetState(1067) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9239,7 +9541,7 @@ func (p *MDLParser) NavMenuItemDef() (localctx INavMenuItemDefContext) { if _la == MDLParserSEMICOLON { { - p.SetState(1027) + p.SetState(1066) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -9296,6 +9598,7 @@ type IDropStatementContext interface { SERVICE() antlr.TerminalNode BUSINESS() antlr.TerminalNode EVENT() antlr.TerminalNode + WORKFLOW() antlr.TerminalNode // IsDropStatementContext differentiates from other interfaces. IsDropStatementContext() @@ -9454,6 +9757,10 @@ func (s *DropStatementContext) EVENT() antlr.TerminalNode { return s.GetToken(MDLParserEVENT, 0) } +func (s *DropStatementContext) WORKFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserWORKFLOW, 0) +} + func (s *DropStatementContext) GetRuleContext() antlr.RuleContext { return s } @@ -9477,7 +9784,7 @@ func (s *DropStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { localctx = NewDropStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 32, MDLParserRULE_dropStatement) - p.SetState(1085) + p.SetState(1127) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9487,7 +9794,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1032) + p.SetState(1071) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9495,7 +9802,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1033) + p.SetState(1072) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -9503,14 +9810,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1034) + p.SetState(1073) p.QualifiedName() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1035) + p.SetState(1074) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9518,7 +9825,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1036) + p.SetState(1075) p.Match(MDLParserASSOCIATION) if p.HasError() { // Recognition error - abort rule @@ -9526,14 +9833,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1037) + p.SetState(1076) p.QualifiedName() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1038) + p.SetState(1077) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9541,7 +9848,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1039) + p.SetState(1078) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -9549,14 +9856,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1040) + p.SetState(1079) p.QualifiedName() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1041) + p.SetState(1080) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9564,7 +9871,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1042) + p.SetState(1081) p.Match(MDLParserCONSTANT) if p.HasError() { // Recognition error - abort rule @@ -9572,14 +9879,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1043) + p.SetState(1082) p.QualifiedName() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1044) + p.SetState(1083) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9587,7 +9894,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1045) + p.SetState(1084) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -9595,14 +9902,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1046) + p.SetState(1085) p.QualifiedName() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1047) + p.SetState(1086) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9610,7 +9917,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1048) + p.SetState(1087) p.Match(MDLParserNANOFLOW) if p.HasError() { // Recognition error - abort rule @@ -9618,14 +9925,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1049) + p.SetState(1088) p.QualifiedName() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(1050) + p.SetState(1089) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9633,7 +9940,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1051) + p.SetState(1090) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -9641,14 +9948,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1052) + p.SetState(1091) p.QualifiedName() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(1053) + p.SetState(1092) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9656,7 +9963,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1054) + p.SetState(1093) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -9664,14 +9971,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1055) + p.SetState(1094) p.QualifiedName() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(1056) + p.SetState(1095) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9679,7 +9986,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1057) + p.SetState(1096) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -9687,14 +9994,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1058) + p.SetState(1097) p.QualifiedName() } case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(1059) + p.SetState(1098) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9702,7 +10009,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1060) + p.SetState(1099) p.Match(MDLParserNOTEBOOK) if p.HasError() { // Recognition error - abort rule @@ -9710,14 +10017,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1061) + p.SetState(1100) p.QualifiedName() } case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(1062) + p.SetState(1101) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9725,7 +10032,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1063) + p.SetState(1102) p.Match(MDLParserJAVA) if p.HasError() { // Recognition error - abort rule @@ -9733,7 +10040,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1064) + p.SetState(1103) p.Match(MDLParserACTION) if p.HasError() { // Recognition error - abort rule @@ -9741,14 +10048,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1065) + p.SetState(1104) p.QualifiedName() } case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(1066) + p.SetState(1105) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9756,7 +10063,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1067) + p.SetState(1106) p.Match(MDLParserINDEX) if p.HasError() { // Recognition error - abort rule @@ -9764,11 +10071,11 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1068) + p.SetState(1107) p.QualifiedName() } { - p.SetState(1069) + p.SetState(1108) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -9776,14 +10083,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1070) + p.SetState(1109) p.QualifiedName() } case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(1072) + p.SetState(1111) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9791,7 +10098,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1073) + p.SetState(1112) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -9799,7 +10106,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1074) + p.SetState(1113) p.Match(MDLParserCLIENT) if p.HasError() { // Recognition error - abort rule @@ -9807,14 +10114,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1075) + p.SetState(1114) p.QualifiedName() } case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(1076) + p.SetState(1115) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9822,7 +10129,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1077) + p.SetState(1116) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -9830,7 +10137,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1078) + p.SetState(1117) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -9838,14 +10145,14 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1079) + p.SetState(1118) p.QualifiedName() } case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(1080) + p.SetState(1119) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -9853,7 +10160,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1081) + p.SetState(1120) p.Match(MDLParserBUSINESS) if p.HasError() { // Recognition error - abort rule @@ -9861,7 +10168,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1082) + p.SetState(1121) p.Match(MDLParserEVENT) if p.HasError() { // Recognition error - abort rule @@ -9869,7 +10176,7 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1083) + p.SetState(1122) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -9877,7 +10184,30 @@ func (p *MDLParser) DropStatement() (localctx IDropStatementContext) { } } { - p.SetState(1084) + p.SetState(1123) + p.QualifiedName() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1124) + p.Match(MDLParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1125) + p.Match(MDLParserWORKFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1126) p.QualifiedName() } @@ -10013,7 +10343,7 @@ func (s *RenameStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { localctx = NewRenameStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 34, MDLParserRULE_renameStatement) - p.SetState(1098) + p.SetState(1140) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10023,7 +10353,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1087) + p.SetState(1129) p.Match(MDLParserRENAME) if p.HasError() { // Recognition error - abort rule @@ -10031,7 +10361,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { } } { - p.SetState(1088) + p.SetState(1130) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -10039,11 +10369,11 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { } } { - p.SetState(1089) + p.SetState(1131) p.QualifiedName() } { - p.SetState(1090) + p.SetState(1132) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -10051,7 +10381,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { } } { - p.SetState(1091) + p.SetState(1133) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -10062,7 +10392,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1093) + p.SetState(1135) p.Match(MDLParserRENAME) if p.HasError() { // Recognition error - abort rule @@ -10070,7 +10400,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { } } { - p.SetState(1094) + p.SetState(1136) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -10078,7 +10408,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { } } { - p.SetState(1095) + p.SetState(1137) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -10086,7 +10416,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { } } { - p.SetState(1096) + p.SetState(1138) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -10094,7 +10424,7 @@ func (p *MDLParser) RenameStatement() (localctx IRenameStatementContext) { } } { - p.SetState(1097) + p.SetState(1139) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -10307,7 +10637,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { p.EnterRule(localctx, 36, MDLParserRULE_moveStatement) var _la int - p.SetState(1147) + p.SetState(1189) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10317,14 +10647,14 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1100) + p.SetState(1142) p.Match(MDLParserMOVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1109) + p.SetState(1151) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10333,7 +10663,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { switch p.GetTokenStream().LA(1) { case MDLParserPAGE: { - p.SetState(1101) + p.SetState(1143) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -10343,7 +10673,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserMICROFLOW: { - p.SetState(1102) + p.SetState(1144) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -10353,7 +10683,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserSNIPPET: { - p.SetState(1103) + p.SetState(1145) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -10363,7 +10693,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserNANOFLOW: { - p.SetState(1104) + p.SetState(1146) p.Match(MDLParserNANOFLOW) if p.HasError() { // Recognition error - abort rule @@ -10373,7 +10703,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserENUMERATION: { - p.SetState(1105) + p.SetState(1147) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -10383,7 +10713,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserCONSTANT: { - p.SetState(1106) + p.SetState(1148) p.Match(MDLParserCONSTANT) if p.HasError() { // Recognition error - abort rule @@ -10393,7 +10723,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserDATABASE: { - p.SetState(1107) + p.SetState(1149) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -10401,7 +10731,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { } } { - p.SetState(1108) + p.SetState(1150) p.Match(MDLParserCONNECTION) if p.HasError() { // Recognition error - abort rule @@ -10414,11 +10744,11 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { goto errorExit } { - p.SetState(1111) + p.SetState(1153) p.QualifiedName() } { - p.SetState(1112) + p.SetState(1154) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -10426,7 +10756,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { } } { - p.SetState(1113) + p.SetState(1155) p.Match(MDLParserFOLDER) if p.HasError() { // Recognition error - abort rule @@ -10434,14 +10764,14 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { } } { - p.SetState(1114) + p.SetState(1156) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1120) + p.SetState(1162) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10450,14 +10780,14 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { if _la == MDLParserIN { { - p.SetState(1115) + p.SetState(1157) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1118) + p.SetState(1160) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10466,13 +10796,13 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) { case 1: { - p.SetState(1116) + p.SetState(1158) p.QualifiedName() } case 2: { - p.SetState(1117) + p.SetState(1159) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -10489,14 +10819,14 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1122) + p.SetState(1164) p.Match(MDLParserMOVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1131) + p.SetState(1173) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10505,7 +10835,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { switch p.GetTokenStream().LA(1) { case MDLParserPAGE: { - p.SetState(1123) + p.SetState(1165) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -10515,7 +10845,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserMICROFLOW: { - p.SetState(1124) + p.SetState(1166) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -10525,7 +10855,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserSNIPPET: { - p.SetState(1125) + p.SetState(1167) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -10535,7 +10865,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserNANOFLOW: { - p.SetState(1126) + p.SetState(1168) p.Match(MDLParserNANOFLOW) if p.HasError() { // Recognition error - abort rule @@ -10545,7 +10875,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserENUMERATION: { - p.SetState(1127) + p.SetState(1169) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -10555,7 +10885,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserCONSTANT: { - p.SetState(1128) + p.SetState(1170) p.Match(MDLParserCONSTANT) if p.HasError() { // Recognition error - abort rule @@ -10565,7 +10895,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case MDLParserDATABASE: { - p.SetState(1129) + p.SetState(1171) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -10573,7 +10903,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { } } { - p.SetState(1130) + p.SetState(1172) p.Match(MDLParserCONNECTION) if p.HasError() { // Recognition error - abort rule @@ -10586,18 +10916,18 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { goto errorExit } { - p.SetState(1133) + p.SetState(1175) p.QualifiedName() } { - p.SetState(1134) + p.SetState(1176) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1137) + p.SetState(1179) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10606,13 +10936,13 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 52, p.GetParserRuleContext()) { case 1: { - p.SetState(1135) + p.SetState(1177) p.QualifiedName() } case 2: { - p.SetState(1136) + p.SetState(1178) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -10627,7 +10957,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1139) + p.SetState(1181) p.Match(MDLParserMOVE) if p.HasError() { // Recognition error - abort rule @@ -10635,7 +10965,7 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { } } { - p.SetState(1140) + p.SetState(1182) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -10643,18 +10973,18 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { } } { - p.SetState(1141) + p.SetState(1183) p.QualifiedName() } { - p.SetState(1142) + p.SetState(1184) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1145) + p.SetState(1187) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10663,13 +10993,13 @@ func (p *MDLParser) MoveStatement() (localctx IMoveStatementContext) { switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 53, p.GetParserRuleContext()) { case 1: { - p.SetState(1143) + p.SetState(1185) p.QualifiedName() } case 2: { - p.SetState(1144) + p.SetState(1186) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -10717,6 +11047,8 @@ type ISecurityStatementContext interface { RevokeMicroflowAccessStatement() IRevokeMicroflowAccessStatementContext GrantPageAccessStatement() IGrantPageAccessStatementContext RevokePageAccessStatement() IRevokePageAccessStatementContext + GrantWorkflowAccessStatement() IGrantWorkflowAccessStatementContext + RevokeWorkflowAccessStatement() IRevokeWorkflowAccessStatementContext GrantODataServiceAccessStatement() IGrantODataServiceAccessStatementContext RevokeODataServiceAccessStatement() IRevokeODataServiceAccessStatementContext AlterProjectSecurityStatement() IAlterProjectSecurityStatementContext @@ -10936,6 +11268,38 @@ func (s *SecurityStatementContext) RevokePageAccessStatement() IRevokePageAccess return t.(IRevokePageAccessStatementContext) } +func (s *SecurityStatementContext) GrantWorkflowAccessStatement() IGrantWorkflowAccessStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantWorkflowAccessStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantWorkflowAccessStatementContext) +} + +func (s *SecurityStatementContext) RevokeWorkflowAccessStatement() IRevokeWorkflowAccessStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokeWorkflowAccessStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokeWorkflowAccessStatementContext) +} + func (s *SecurityStatementContext) GrantODataServiceAccessStatement() IGrantODataServiceAccessStatementContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { @@ -11055,7 +11419,7 @@ func (s *SecurityStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SecurityStatement() (localctx ISecurityStatementContext) { localctx = NewSecurityStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 38, MDLParserRULE_securityStatement) - p.SetState(1166) + p.SetState(1210) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11065,119 +11429,133 @@ func (p *MDLParser) SecurityStatement() (localctx ISecurityStatementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1149) + p.SetState(1191) p.CreateModuleRoleStatement() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1150) + p.SetState(1192) p.DropModuleRoleStatement() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1151) + p.SetState(1193) p.CreateUserRoleStatement() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1152) + p.SetState(1194) p.AlterUserRoleStatement() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1153) + p.SetState(1195) p.DropUserRoleStatement() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1154) + p.SetState(1196) p.GrantEntityAccessStatement() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(1155) + p.SetState(1197) p.RevokeEntityAccessStatement() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(1156) + p.SetState(1198) p.GrantMicroflowAccessStatement() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(1157) + p.SetState(1199) p.RevokeMicroflowAccessStatement() } case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(1158) + p.SetState(1200) p.GrantPageAccessStatement() } case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(1159) + p.SetState(1201) p.RevokePageAccessStatement() } case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(1160) - p.GrantODataServiceAccessStatement() + p.SetState(1202) + p.GrantWorkflowAccessStatement() } case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(1161) - p.RevokeODataServiceAccessStatement() + p.SetState(1203) + p.RevokeWorkflowAccessStatement() } case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(1162) - p.AlterProjectSecurityStatement() + p.SetState(1204) + p.GrantODataServiceAccessStatement() } case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(1163) - p.CreateDemoUserStatement() + p.SetState(1205) + p.RevokeODataServiceAccessStatement() } case 16: p.EnterOuterAlt(localctx, 16) { - p.SetState(1164) - p.DropDemoUserStatement() + p.SetState(1206) + p.AlterProjectSecurityStatement() } case 17: p.EnterOuterAlt(localctx, 17) { - p.SetState(1165) + p.SetState(1207) + p.CreateDemoUserStatement() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(1208) + p.DropDemoUserStatement() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(1209) p.UpdateSecurityStatement() } @@ -11312,7 +11690,7 @@ func (p *MDLParser) CreateModuleRoleStatement() (localctx ICreateModuleRoleState p.EnterOuterAlt(localctx, 1) { - p.SetState(1168) + p.SetState(1212) p.Match(MDLParserCREATE) if p.HasError() { // Recognition error - abort rule @@ -11320,7 +11698,7 @@ func (p *MDLParser) CreateModuleRoleStatement() (localctx ICreateModuleRoleState } } { - p.SetState(1169) + p.SetState(1213) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -11328,7 +11706,7 @@ func (p *MDLParser) CreateModuleRoleStatement() (localctx ICreateModuleRoleState } } { - p.SetState(1170) + p.SetState(1214) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -11336,10 +11714,10 @@ func (p *MDLParser) CreateModuleRoleStatement() (localctx ICreateModuleRoleState } } { - p.SetState(1171) + p.SetState(1215) p.QualifiedName() } - p.SetState(1174) + p.SetState(1218) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11348,7 +11726,7 @@ func (p *MDLParser) CreateModuleRoleStatement() (localctx ICreateModuleRoleState if _la == MDLParserDESCRIPTION { { - p.SetState(1172) + p.SetState(1216) p.Match(MDLParserDESCRIPTION) if p.HasError() { // Recognition error - abort rule @@ -11356,7 +11734,7 @@ func (p *MDLParser) CreateModuleRoleStatement() (localctx ICreateModuleRoleState } } { - p.SetState(1173) + p.SetState(1217) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -11481,7 +11859,7 @@ func (p *MDLParser) DropModuleRoleStatement() (localctx IDropModuleRoleStatement p.EnterRule(localctx, 42, MDLParserRULE_dropModuleRoleStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1176) + p.SetState(1220) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -11489,7 +11867,7 @@ func (p *MDLParser) DropModuleRoleStatement() (localctx IDropModuleRoleStatement } } { - p.SetState(1177) + p.SetState(1221) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -11497,7 +11875,7 @@ func (p *MDLParser) DropModuleRoleStatement() (localctx IDropModuleRoleStatement } } { - p.SetState(1178) + p.SetState(1222) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -11505,7 +11883,7 @@ func (p *MDLParser) DropModuleRoleStatement() (localctx IDropModuleRoleStatement } } { - p.SetState(1179) + p.SetState(1223) p.QualifiedName() } @@ -11668,7 +12046,7 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement p.EnterOuterAlt(localctx, 1) { - p.SetState(1181) + p.SetState(1225) p.Match(MDLParserCREATE) if p.HasError() { // Recognition error - abort rule @@ -11676,7 +12054,7 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement } } { - p.SetState(1182) + p.SetState(1226) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -11684,7 +12062,7 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement } } { - p.SetState(1183) + p.SetState(1227) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -11692,11 +12070,11 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement } } { - p.SetState(1184) + p.SetState(1228) p.IdentifierOrKeyword() } { - p.SetState(1185) + p.SetState(1229) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -11704,18 +12082,18 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement } } { - p.SetState(1186) + p.SetState(1230) p.ModuleRoleList() } { - p.SetState(1187) + p.SetState(1231) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1191) + p.SetState(1235) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11724,7 +12102,7 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement if _la == MDLParserMANAGE { { - p.SetState(1188) + p.SetState(1232) p.Match(MDLParserMANAGE) if p.HasError() { // Recognition error - abort rule @@ -11732,7 +12110,7 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement } } { - p.SetState(1189) + p.SetState(1233) p.Match(MDLParserALL) if p.HasError() { // Recognition error - abort rule @@ -11740,7 +12118,7 @@ func (p *MDLParser) CreateUserRoleStatement() (localctx ICreateUserRoleStatement } } { - p.SetState(1190) + p.SetState(1234) p.Match(MDLParserROLES) if p.HasError() { // Recognition error - abort rule @@ -11910,7 +12288,7 @@ func (s *AlterUserRoleStatementContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementContext) { localctx = NewAlterUserRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 46, MDLParserRULE_alterUserRoleStatement) - p.SetState(1215) + p.SetState(1259) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11920,7 +12298,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1193) + p.SetState(1237) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -11928,7 +12306,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1194) + p.SetState(1238) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -11936,7 +12314,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1195) + p.SetState(1239) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -11944,11 +12322,11 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1196) + p.SetState(1240) p.IdentifierOrKeyword() } { - p.SetState(1197) + p.SetState(1241) p.Match(MDLParserADD) if p.HasError() { // Recognition error - abort rule @@ -11956,7 +12334,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1198) + p.SetState(1242) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -11964,7 +12342,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1199) + p.SetState(1243) p.Match(MDLParserROLES) if p.HasError() { // Recognition error - abort rule @@ -11972,7 +12350,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1200) + p.SetState(1244) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -11980,11 +12358,11 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1201) + p.SetState(1245) p.ModuleRoleList() } { - p.SetState(1202) + p.SetState(1246) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -11995,7 +12373,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1204) + p.SetState(1248) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -12003,7 +12381,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1205) + p.SetState(1249) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -12011,7 +12389,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1206) + p.SetState(1250) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -12019,11 +12397,11 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1207) + p.SetState(1251) p.IdentifierOrKeyword() } { - p.SetState(1208) + p.SetState(1252) p.Match(MDLParserREMOVE) if p.HasError() { // Recognition error - abort rule @@ -12031,7 +12409,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1209) + p.SetState(1253) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -12039,7 +12417,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1210) + p.SetState(1254) p.Match(MDLParserROLES) if p.HasError() { // Recognition error - abort rule @@ -12047,7 +12425,7 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1211) + p.SetState(1255) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -12055,11 +12433,11 @@ func (p *MDLParser) AlterUserRoleStatement() (localctx IAlterUserRoleStatementCo } } { - p.SetState(1212) + p.SetState(1256) p.ModuleRoleList() } { - p.SetState(1213) + p.SetState(1257) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -12186,7 +12564,7 @@ func (p *MDLParser) DropUserRoleStatement() (localctx IDropUserRoleStatementCont p.EnterRule(localctx, 48, MDLParserRULE_dropUserRoleStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1217) + p.SetState(1261) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -12194,7 +12572,7 @@ func (p *MDLParser) DropUserRoleStatement() (localctx IDropUserRoleStatementCont } } { - p.SetState(1218) + p.SetState(1262) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -12202,7 +12580,7 @@ func (p *MDLParser) DropUserRoleStatement() (localctx IDropUserRoleStatementCont } } { - p.SetState(1219) + p.SetState(1263) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -12210,7 +12588,7 @@ func (p *MDLParser) DropUserRoleStatement() (localctx IDropUserRoleStatementCont } } { - p.SetState(1220) + p.SetState(1264) p.IdentifierOrKeyword() } @@ -12380,7 +12758,7 @@ func (p *MDLParser) GrantEntityAccessStatement() (localctx IGrantEntityAccessSta p.EnterOuterAlt(localctx, 1) { - p.SetState(1222) + p.SetState(1266) p.Match(MDLParserGRANT) if p.HasError() { // Recognition error - abort rule @@ -12388,11 +12766,11 @@ func (p *MDLParser) GrantEntityAccessStatement() (localctx IGrantEntityAccessSta } } { - p.SetState(1223) + p.SetState(1267) p.ModuleRoleList() } { - p.SetState(1224) + p.SetState(1268) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -12400,11 +12778,11 @@ func (p *MDLParser) GrantEntityAccessStatement() (localctx IGrantEntityAccessSta } } { - p.SetState(1225) + p.SetState(1269) p.QualifiedName() } { - p.SetState(1226) + p.SetState(1270) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -12412,18 +12790,18 @@ func (p *MDLParser) GrantEntityAccessStatement() (localctx IGrantEntityAccessSta } } { - p.SetState(1227) + p.SetState(1271) p.EntityAccessRightList() } { - p.SetState(1228) + p.SetState(1272) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1231) + p.SetState(1275) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -12432,7 +12810,7 @@ func (p *MDLParser) GrantEntityAccessStatement() (localctx IGrantEntityAccessSta if _la == MDLParserWHERE { { - p.SetState(1229) + p.SetState(1273) p.Match(MDLParserWHERE) if p.HasError() { // Recognition error - abort rule @@ -12440,7 +12818,7 @@ func (p *MDLParser) GrantEntityAccessStatement() (localctx IGrantEntityAccessSta } } { - p.SetState(1230) + p.SetState(1274) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -12577,7 +12955,7 @@ func (p *MDLParser) RevokeEntityAccessStatement() (localctx IRevokeEntityAccessS p.EnterRule(localctx, 52, MDLParserRULE_revokeEntityAccessStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1233) + p.SetState(1277) p.Match(MDLParserREVOKE) if p.HasError() { // Recognition error - abort rule @@ -12585,11 +12963,11 @@ func (p *MDLParser) RevokeEntityAccessStatement() (localctx IRevokeEntityAccessS } } { - p.SetState(1234) + p.SetState(1278) p.ModuleRoleList() } { - p.SetState(1235) + p.SetState(1279) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -12597,7 +12975,7 @@ func (p *MDLParser) RevokeEntityAccessStatement() (localctx IRevokeEntityAccessS } } { - p.SetState(1236) + p.SetState(1280) p.QualifiedName() } @@ -12743,7 +13121,7 @@ func (p *MDLParser) GrantMicroflowAccessStatement() (localctx IGrantMicroflowAcc p.EnterRule(localctx, 54, MDLParserRULE_grantMicroflowAccessStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1238) + p.SetState(1282) p.Match(MDLParserGRANT) if p.HasError() { // Recognition error - abort rule @@ -12751,7 +13129,7 @@ func (p *MDLParser) GrantMicroflowAccessStatement() (localctx IGrantMicroflowAcc } } { - p.SetState(1239) + p.SetState(1283) p.Match(MDLParserEXECUTE) if p.HasError() { // Recognition error - abort rule @@ -12759,7 +13137,7 @@ func (p *MDLParser) GrantMicroflowAccessStatement() (localctx IGrantMicroflowAcc } } { - p.SetState(1240) + p.SetState(1284) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -12767,7 +13145,7 @@ func (p *MDLParser) GrantMicroflowAccessStatement() (localctx IGrantMicroflowAcc } } { - p.SetState(1241) + p.SetState(1285) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -12775,11 +13153,11 @@ func (p *MDLParser) GrantMicroflowAccessStatement() (localctx IGrantMicroflowAcc } } { - p.SetState(1242) + p.SetState(1286) p.QualifiedName() } { - p.SetState(1243) + p.SetState(1287) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -12787,7 +13165,7 @@ func (p *MDLParser) GrantMicroflowAccessStatement() (localctx IGrantMicroflowAcc } } { - p.SetState(1244) + p.SetState(1288) p.ModuleRoleList() } @@ -12933,7 +13311,7 @@ func (p *MDLParser) RevokeMicroflowAccessStatement() (localctx IRevokeMicroflowA p.EnterRule(localctx, 56, MDLParserRULE_revokeMicroflowAccessStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1246) + p.SetState(1290) p.Match(MDLParserREVOKE) if p.HasError() { // Recognition error - abort rule @@ -12941,7 +13319,7 @@ func (p *MDLParser) RevokeMicroflowAccessStatement() (localctx IRevokeMicroflowA } } { - p.SetState(1247) + p.SetState(1291) p.Match(MDLParserEXECUTE) if p.HasError() { // Recognition error - abort rule @@ -12949,7 +13327,7 @@ func (p *MDLParser) RevokeMicroflowAccessStatement() (localctx IRevokeMicroflowA } } { - p.SetState(1248) + p.SetState(1292) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -12957,7 +13335,7 @@ func (p *MDLParser) RevokeMicroflowAccessStatement() (localctx IRevokeMicroflowA } } { - p.SetState(1249) + p.SetState(1293) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -12965,11 +13343,11 @@ func (p *MDLParser) RevokeMicroflowAccessStatement() (localctx IRevokeMicroflowA } } { - p.SetState(1250) + p.SetState(1294) p.QualifiedName() } { - p.SetState(1251) + p.SetState(1295) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -12977,7 +13355,7 @@ func (p *MDLParser) RevokeMicroflowAccessStatement() (localctx IRevokeMicroflowA } } { - p.SetState(1252) + p.SetState(1296) p.ModuleRoleList() } @@ -13123,7 +13501,7 @@ func (p *MDLParser) GrantPageAccessStatement() (localctx IGrantPageAccessStateme p.EnterRule(localctx, 58, MDLParserRULE_grantPageAccessStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1254) + p.SetState(1298) p.Match(MDLParserGRANT) if p.HasError() { // Recognition error - abort rule @@ -13131,7 +13509,7 @@ func (p *MDLParser) GrantPageAccessStatement() (localctx IGrantPageAccessStateme } } { - p.SetState(1255) + p.SetState(1299) p.Match(MDLParserVIEW) if p.HasError() { // Recognition error - abort rule @@ -13139,7 +13517,7 @@ func (p *MDLParser) GrantPageAccessStatement() (localctx IGrantPageAccessStateme } } { - p.SetState(1256) + p.SetState(1300) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -13147,7 +13525,7 @@ func (p *MDLParser) GrantPageAccessStatement() (localctx IGrantPageAccessStateme } } { - p.SetState(1257) + p.SetState(1301) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -13155,11 +13533,11 @@ func (p *MDLParser) GrantPageAccessStatement() (localctx IGrantPageAccessStateme } } { - p.SetState(1258) + p.SetState(1302) p.QualifiedName() } { - p.SetState(1259) + p.SetState(1303) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -13167,7 +13545,7 @@ func (p *MDLParser) GrantPageAccessStatement() (localctx IGrantPageAccessStateme } } { - p.SetState(1260) + p.SetState(1304) p.ModuleRoleList() } @@ -13313,7 +13691,7 @@ func (p *MDLParser) RevokePageAccessStatement() (localctx IRevokePageAccessState p.EnterRule(localctx, 60, MDLParserRULE_revokePageAccessStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1262) + p.SetState(1306) p.Match(MDLParserREVOKE) if p.HasError() { // Recognition error - abort rule @@ -13321,7 +13699,7 @@ func (p *MDLParser) RevokePageAccessStatement() (localctx IRevokePageAccessState } } { - p.SetState(1263) + p.SetState(1307) p.Match(MDLParserVIEW) if p.HasError() { // Recognition error - abort rule @@ -13329,7 +13707,7 @@ func (p *MDLParser) RevokePageAccessStatement() (localctx IRevokePageAccessState } } { - p.SetState(1264) + p.SetState(1308) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -13337,7 +13715,7 @@ func (p *MDLParser) RevokePageAccessStatement() (localctx IRevokePageAccessState } } { - p.SetState(1265) + p.SetState(1309) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -13345,11 +13723,11 @@ func (p *MDLParser) RevokePageAccessStatement() (localctx IRevokePageAccessState } } { - p.SetState(1266) + p.SetState(1310) p.QualifiedName() } { - p.SetState(1267) + p.SetState(1311) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -13357,7 +13735,7 @@ func (p *MDLParser) RevokePageAccessStatement() (localctx IRevokePageAccessState } } { - p.SetState(1268) + p.SetState(1312) p.ModuleRoleList() } @@ -13374,8 +13752,8 @@ errorExit: goto errorExit // Trick to prevent compiler error if the label is not used } -// IGrantODataServiceAccessStatementContext is an interface to support dynamic dispatch. -type IGrantODataServiceAccessStatementContext interface { +// IGrantWorkflowAccessStatementContext is an interface to support dynamic dispatch. +type IGrantWorkflowAccessStatementContext interface { antlr.ParserRuleContext // GetParser returns the parser. @@ -13383,71 +13761,66 @@ type IGrantODataServiceAccessStatementContext interface { // Getter signatures GRANT() antlr.TerminalNode - ACCESS() antlr.TerminalNode + EXECUTE() antlr.TerminalNode ON() antlr.TerminalNode - ODATA() antlr.TerminalNode - SERVICE() antlr.TerminalNode + WORKFLOW() antlr.TerminalNode QualifiedName() IQualifiedNameContext TO() antlr.TerminalNode ModuleRoleList() IModuleRoleListContext - // IsGrantODataServiceAccessStatementContext differentiates from other interfaces. - IsGrantODataServiceAccessStatementContext() + // IsGrantWorkflowAccessStatementContext differentiates from other interfaces. + IsGrantWorkflowAccessStatementContext() } -type GrantODataServiceAccessStatementContext struct { +type GrantWorkflowAccessStatementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } -func NewEmptyGrantODataServiceAccessStatementContext() *GrantODataServiceAccessStatementContext { - var p = new(GrantODataServiceAccessStatementContext) +func NewEmptyGrantWorkflowAccessStatementContext() *GrantWorkflowAccessStatementContext { + var p = new(GrantWorkflowAccessStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_grantODataServiceAccessStatement + p.RuleIndex = MDLParserRULE_grantWorkflowAccessStatement return p } -func InitEmptyGrantODataServiceAccessStatementContext(p *GrantODataServiceAccessStatementContext) { +func InitEmptyGrantWorkflowAccessStatementContext(p *GrantWorkflowAccessStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_grantODataServiceAccessStatement + p.RuleIndex = MDLParserRULE_grantWorkflowAccessStatement } -func (*GrantODataServiceAccessStatementContext) IsGrantODataServiceAccessStatementContext() {} +func (*GrantWorkflowAccessStatementContext) IsGrantWorkflowAccessStatementContext() {} -func NewGrantODataServiceAccessStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantODataServiceAccessStatementContext { - var p = new(GrantODataServiceAccessStatementContext) +func NewGrantWorkflowAccessStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantWorkflowAccessStatementContext { + var p = new(GrantWorkflowAccessStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = MDLParserRULE_grantODataServiceAccessStatement + p.RuleIndex = MDLParserRULE_grantWorkflowAccessStatement return p } -func (s *GrantODataServiceAccessStatementContext) GetParser() antlr.Parser { return s.parser } +func (s *GrantWorkflowAccessStatementContext) GetParser() antlr.Parser { return s.parser } -func (s *GrantODataServiceAccessStatementContext) GRANT() antlr.TerminalNode { +func (s *GrantWorkflowAccessStatementContext) GRANT() antlr.TerminalNode { return s.GetToken(MDLParserGRANT, 0) } -func (s *GrantODataServiceAccessStatementContext) ACCESS() antlr.TerminalNode { - return s.GetToken(MDLParserACCESS, 0) +func (s *GrantWorkflowAccessStatementContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(MDLParserEXECUTE, 0) } -func (s *GrantODataServiceAccessStatementContext) ON() antlr.TerminalNode { +func (s *GrantWorkflowAccessStatementContext) ON() antlr.TerminalNode { return s.GetToken(MDLParserON, 0) } -func (s *GrantODataServiceAccessStatementContext) ODATA() antlr.TerminalNode { - return s.GetToken(MDLParserODATA, 0) -} - -func (s *GrantODataServiceAccessStatementContext) SERVICE() antlr.TerminalNode { - return s.GetToken(MDLParserSERVICE, 0) +func (s *GrantWorkflowAccessStatementContext) WORKFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserWORKFLOW, 0) } -func (s *GrantODataServiceAccessStatementContext) QualifiedName() IQualifiedNameContext { +func (s *GrantWorkflowAccessStatementContext) QualifiedName() IQualifiedNameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualifiedNameContext); ok { @@ -13463,11 +13836,11 @@ func (s *GrantODataServiceAccessStatementContext) QualifiedName() IQualifiedName return t.(IQualifiedNameContext) } -func (s *GrantODataServiceAccessStatementContext) TO() antlr.TerminalNode { +func (s *GrantWorkflowAccessStatementContext) TO() antlr.TerminalNode { return s.GetToken(MDLParserTO, 0) } -func (s *GrantODataServiceAccessStatementContext) ModuleRoleList() IModuleRoleListContext { +func (s *GrantWorkflowAccessStatementContext) ModuleRoleList() IModuleRoleListContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IModuleRoleListContext); ok { @@ -13483,32 +13856,32 @@ func (s *GrantODataServiceAccessStatementContext) ModuleRoleList() IModuleRoleLi return t.(IModuleRoleListContext) } -func (s *GrantODataServiceAccessStatementContext) GetRuleContext() antlr.RuleContext { +func (s *GrantWorkflowAccessStatementContext) GetRuleContext() antlr.RuleContext { return s } -func (s *GrantODataServiceAccessStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { +func (s *GrantWorkflowAccessStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } -func (s *GrantODataServiceAccessStatementContext) EnterRule(listener antlr.ParseTreeListener) { +func (s *GrantWorkflowAccessStatementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.EnterGrantODataServiceAccessStatement(s) + listenerT.EnterGrantWorkflowAccessStatement(s) } } -func (s *GrantODataServiceAccessStatementContext) ExitRule(listener antlr.ParseTreeListener) { +func (s *GrantWorkflowAccessStatementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.ExitGrantODataServiceAccessStatement(s) + listenerT.ExitGrantWorkflowAccessStatement(s) } } -func (p *MDLParser) GrantODataServiceAccessStatement() (localctx IGrantODataServiceAccessStatementContext) { - localctx = NewGrantODataServiceAccessStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 62, MDLParserRULE_grantODataServiceAccessStatement) +func (p *MDLParser) GrantWorkflowAccessStatement() (localctx IGrantWorkflowAccessStatementContext) { + localctx = NewGrantWorkflowAccessStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, MDLParserRULE_grantWorkflowAccessStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1270) + p.SetState(1314) p.Match(MDLParserGRANT) if p.HasError() { // Recognition error - abort rule @@ -13516,15 +13889,15 @@ func (p *MDLParser) GrantODataServiceAccessStatement() (localctx IGrantODataServ } } { - p.SetState(1271) - p.Match(MDLParserACCESS) + p.SetState(1315) + p.Match(MDLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(1272) + p.SetState(1316) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -13532,27 +13905,19 @@ func (p *MDLParser) GrantODataServiceAccessStatement() (localctx IGrantODataServ } } { - p.SetState(1273) - p.Match(MDLParserODATA) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(1274) - p.Match(MDLParserSERVICE) + p.SetState(1317) + p.Match(MDLParserWORKFLOW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(1275) + p.SetState(1318) p.QualifiedName() } { - p.SetState(1276) + p.SetState(1319) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -13560,7 +13925,7 @@ func (p *MDLParser) GrantODataServiceAccessStatement() (localctx IGrantODataServ } } { - p.SetState(1277) + p.SetState(1320) p.ModuleRoleList() } @@ -13577,8 +13942,8 @@ errorExit: goto errorExit // Trick to prevent compiler error if the label is not used } -// IRevokeODataServiceAccessStatementContext is an interface to support dynamic dispatch. -type IRevokeODataServiceAccessStatementContext interface { +// IRevokeWorkflowAccessStatementContext is an interface to support dynamic dispatch. +type IRevokeWorkflowAccessStatementContext interface { antlr.ParserRuleContext // GetParser returns the parser. @@ -13586,71 +13951,66 @@ type IRevokeODataServiceAccessStatementContext interface { // Getter signatures REVOKE() antlr.TerminalNode - ACCESS() antlr.TerminalNode + EXECUTE() antlr.TerminalNode ON() antlr.TerminalNode - ODATA() antlr.TerminalNode - SERVICE() antlr.TerminalNode + WORKFLOW() antlr.TerminalNode QualifiedName() IQualifiedNameContext FROM() antlr.TerminalNode ModuleRoleList() IModuleRoleListContext - // IsRevokeODataServiceAccessStatementContext differentiates from other interfaces. - IsRevokeODataServiceAccessStatementContext() + // IsRevokeWorkflowAccessStatementContext differentiates from other interfaces. + IsRevokeWorkflowAccessStatementContext() } -type RevokeODataServiceAccessStatementContext struct { +type RevokeWorkflowAccessStatementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } -func NewEmptyRevokeODataServiceAccessStatementContext() *RevokeODataServiceAccessStatementContext { - var p = new(RevokeODataServiceAccessStatementContext) +func NewEmptyRevokeWorkflowAccessStatementContext() *RevokeWorkflowAccessStatementContext { + var p = new(RevokeWorkflowAccessStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_revokeODataServiceAccessStatement + p.RuleIndex = MDLParserRULE_revokeWorkflowAccessStatement return p } -func InitEmptyRevokeODataServiceAccessStatementContext(p *RevokeODataServiceAccessStatementContext) { +func InitEmptyRevokeWorkflowAccessStatementContext(p *RevokeWorkflowAccessStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_revokeODataServiceAccessStatement + p.RuleIndex = MDLParserRULE_revokeWorkflowAccessStatement } -func (*RevokeODataServiceAccessStatementContext) IsRevokeODataServiceAccessStatementContext() {} +func (*RevokeWorkflowAccessStatementContext) IsRevokeWorkflowAccessStatementContext() {} -func NewRevokeODataServiceAccessStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeODataServiceAccessStatementContext { - var p = new(RevokeODataServiceAccessStatementContext) +func NewRevokeWorkflowAccessStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeWorkflowAccessStatementContext { + var p = new(RevokeWorkflowAccessStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = MDLParserRULE_revokeODataServiceAccessStatement + p.RuleIndex = MDLParserRULE_revokeWorkflowAccessStatement return p } -func (s *RevokeODataServiceAccessStatementContext) GetParser() antlr.Parser { return s.parser } +func (s *RevokeWorkflowAccessStatementContext) GetParser() antlr.Parser { return s.parser } -func (s *RevokeODataServiceAccessStatementContext) REVOKE() antlr.TerminalNode { +func (s *RevokeWorkflowAccessStatementContext) REVOKE() antlr.TerminalNode { return s.GetToken(MDLParserREVOKE, 0) } -func (s *RevokeODataServiceAccessStatementContext) ACCESS() antlr.TerminalNode { - return s.GetToken(MDLParserACCESS, 0) +func (s *RevokeWorkflowAccessStatementContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(MDLParserEXECUTE, 0) } -func (s *RevokeODataServiceAccessStatementContext) ON() antlr.TerminalNode { +func (s *RevokeWorkflowAccessStatementContext) ON() antlr.TerminalNode { return s.GetToken(MDLParserON, 0) } -func (s *RevokeODataServiceAccessStatementContext) ODATA() antlr.TerminalNode { - return s.GetToken(MDLParserODATA, 0) -} - -func (s *RevokeODataServiceAccessStatementContext) SERVICE() antlr.TerminalNode { - return s.GetToken(MDLParserSERVICE, 0) +func (s *RevokeWorkflowAccessStatementContext) WORKFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserWORKFLOW, 0) } -func (s *RevokeODataServiceAccessStatementContext) QualifiedName() IQualifiedNameContext { +func (s *RevokeWorkflowAccessStatementContext) QualifiedName() IQualifiedNameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualifiedNameContext); ok { @@ -13666,11 +14026,11 @@ func (s *RevokeODataServiceAccessStatementContext) QualifiedName() IQualifiedNam return t.(IQualifiedNameContext) } -func (s *RevokeODataServiceAccessStatementContext) FROM() antlr.TerminalNode { +func (s *RevokeWorkflowAccessStatementContext) FROM() antlr.TerminalNode { return s.GetToken(MDLParserFROM, 0) } -func (s *RevokeODataServiceAccessStatementContext) ModuleRoleList() IModuleRoleListContext { +func (s *RevokeWorkflowAccessStatementContext) ModuleRoleList() IModuleRoleListContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IModuleRoleListContext); ok { @@ -13686,32 +14046,32 @@ func (s *RevokeODataServiceAccessStatementContext) ModuleRoleList() IModuleRoleL return t.(IModuleRoleListContext) } -func (s *RevokeODataServiceAccessStatementContext) GetRuleContext() antlr.RuleContext { +func (s *RevokeWorkflowAccessStatementContext) GetRuleContext() antlr.RuleContext { return s } -func (s *RevokeODataServiceAccessStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { +func (s *RevokeWorkflowAccessStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } -func (s *RevokeODataServiceAccessStatementContext) EnterRule(listener antlr.ParseTreeListener) { +func (s *RevokeWorkflowAccessStatementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.EnterRevokeODataServiceAccessStatement(s) + listenerT.EnterRevokeWorkflowAccessStatement(s) } } -func (s *RevokeODataServiceAccessStatementContext) ExitRule(listener antlr.ParseTreeListener) { +func (s *RevokeWorkflowAccessStatementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.ExitRevokeODataServiceAccessStatement(s) + listenerT.ExitRevokeWorkflowAccessStatement(s) } } -func (p *MDLParser) RevokeODataServiceAccessStatement() (localctx IRevokeODataServiceAccessStatementContext) { - localctx = NewRevokeODataServiceAccessStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 64, MDLParserRULE_revokeODataServiceAccessStatement) +func (p *MDLParser) RevokeWorkflowAccessStatement() (localctx IRevokeWorkflowAccessStatementContext) { + localctx = NewRevokeWorkflowAccessStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, MDLParserRULE_revokeWorkflowAccessStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1279) + p.SetState(1322) p.Match(MDLParserREVOKE) if p.HasError() { // Recognition error - abort rule @@ -13719,15 +14079,15 @@ func (p *MDLParser) RevokeODataServiceAccessStatement() (localctx IRevokeODataSe } } { - p.SetState(1280) - p.Match(MDLParserACCESS) + p.SetState(1323) + p.Match(MDLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(1281) + p.SetState(1324) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -13735,27 +14095,19 @@ func (p *MDLParser) RevokeODataServiceAccessStatement() (localctx IRevokeODataSe } } { - p.SetState(1282) - p.Match(MDLParserODATA) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(1283) - p.Match(MDLParserSERVICE) + p.SetState(1325) + p.Match(MDLParserWORKFLOW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(1284) + p.SetState(1326) p.QualifiedName() } { - p.SetState(1285) + p.SetState(1327) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -13763,7 +14115,7 @@ func (p *MDLParser) RevokeODataServiceAccessStatement() (localctx IRevokeODataSe } } { - p.SetState(1286) + p.SetState(1328) p.ModuleRoleList() } @@ -13780,173 +14132,579 @@ errorExit: goto errorExit // Trick to prevent compiler error if the label is not used } -// IAlterProjectSecurityStatementContext is an interface to support dynamic dispatch. -type IAlterProjectSecurityStatementContext interface { +// IGrantODataServiceAccessStatementContext is an interface to support dynamic dispatch. +type IGrantODataServiceAccessStatementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures - ALTER() antlr.TerminalNode - PROJECT() antlr.TerminalNode - SECURITY() antlr.TerminalNode - LEVEL() antlr.TerminalNode - PRODUCTION() antlr.TerminalNode - PROTOTYPE() antlr.TerminalNode - OFF() antlr.TerminalNode - DEMO() antlr.TerminalNode - USERS() antlr.TerminalNode + GRANT() antlr.TerminalNode + ACCESS() antlr.TerminalNode ON() antlr.TerminalNode + ODATA() antlr.TerminalNode + SERVICE() antlr.TerminalNode + QualifiedName() IQualifiedNameContext + TO() antlr.TerminalNode + ModuleRoleList() IModuleRoleListContext - // IsAlterProjectSecurityStatementContext differentiates from other interfaces. - IsAlterProjectSecurityStatementContext() + // IsGrantODataServiceAccessStatementContext differentiates from other interfaces. + IsGrantODataServiceAccessStatementContext() } -type AlterProjectSecurityStatementContext struct { +type GrantODataServiceAccessStatementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } -func NewEmptyAlterProjectSecurityStatementContext() *AlterProjectSecurityStatementContext { - var p = new(AlterProjectSecurityStatementContext) +func NewEmptyGrantODataServiceAccessStatementContext() *GrantODataServiceAccessStatementContext { + var p = new(GrantODataServiceAccessStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_alterProjectSecurityStatement + p.RuleIndex = MDLParserRULE_grantODataServiceAccessStatement return p } -func InitEmptyAlterProjectSecurityStatementContext(p *AlterProjectSecurityStatementContext) { +func InitEmptyGrantODataServiceAccessStatementContext(p *GrantODataServiceAccessStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_alterProjectSecurityStatement + p.RuleIndex = MDLParserRULE_grantODataServiceAccessStatement } -func (*AlterProjectSecurityStatementContext) IsAlterProjectSecurityStatementContext() {} +func (*GrantODataServiceAccessStatementContext) IsGrantODataServiceAccessStatementContext() {} -func NewAlterProjectSecurityStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterProjectSecurityStatementContext { - var p = new(AlterProjectSecurityStatementContext) +func NewGrantODataServiceAccessStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantODataServiceAccessStatementContext { + var p = new(GrantODataServiceAccessStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = MDLParserRULE_alterProjectSecurityStatement + p.RuleIndex = MDLParserRULE_grantODataServiceAccessStatement return p } -func (s *AlterProjectSecurityStatementContext) GetParser() antlr.Parser { return s.parser } +func (s *GrantODataServiceAccessStatementContext) GetParser() antlr.Parser { return s.parser } -func (s *AlterProjectSecurityStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(MDLParserALTER, 0) +func (s *GrantODataServiceAccessStatementContext) GRANT() antlr.TerminalNode { + return s.GetToken(MDLParserGRANT, 0) } -func (s *AlterProjectSecurityStatementContext) PROJECT() antlr.TerminalNode { - return s.GetToken(MDLParserPROJECT, 0) +func (s *GrantODataServiceAccessStatementContext) ACCESS() antlr.TerminalNode { + return s.GetToken(MDLParserACCESS, 0) } -func (s *AlterProjectSecurityStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(MDLParserSECURITY, 0) +func (s *GrantODataServiceAccessStatementContext) ON() antlr.TerminalNode { + return s.GetToken(MDLParserON, 0) } -func (s *AlterProjectSecurityStatementContext) LEVEL() antlr.TerminalNode { - return s.GetToken(MDLParserLEVEL, 0) +func (s *GrantODataServiceAccessStatementContext) ODATA() antlr.TerminalNode { + return s.GetToken(MDLParserODATA, 0) } -func (s *AlterProjectSecurityStatementContext) PRODUCTION() antlr.TerminalNode { - return s.GetToken(MDLParserPRODUCTION, 0) +func (s *GrantODataServiceAccessStatementContext) SERVICE() antlr.TerminalNode { + return s.GetToken(MDLParserSERVICE, 0) } -func (s *AlterProjectSecurityStatementContext) PROTOTYPE() antlr.TerminalNode { - return s.GetToken(MDLParserPROTOTYPE, 0) -} +func (s *GrantODataServiceAccessStatementContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } -func (s *AlterProjectSecurityStatementContext) OFF() antlr.TerminalNode { - return s.GetToken(MDLParserOFF, 0) -} + if t == nil { + return nil + } -func (s *AlterProjectSecurityStatementContext) DEMO() antlr.TerminalNode { - return s.GetToken(MDLParserDEMO, 0) + return t.(IQualifiedNameContext) } -func (s *AlterProjectSecurityStatementContext) USERS() antlr.TerminalNode { - return s.GetToken(MDLParserUSERS, 0) +func (s *GrantODataServiceAccessStatementContext) TO() antlr.TerminalNode { + return s.GetToken(MDLParserTO, 0) } -func (s *AlterProjectSecurityStatementContext) ON() antlr.TerminalNode { - return s.GetToken(MDLParserON, 0) +func (s *GrantODataServiceAccessStatementContext) ModuleRoleList() IModuleRoleListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModuleRoleListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModuleRoleListContext) } -func (s *AlterProjectSecurityStatementContext) GetRuleContext() antlr.RuleContext { +func (s *GrantODataServiceAccessStatementContext) GetRuleContext() antlr.RuleContext { return s } -func (s *AlterProjectSecurityStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { +func (s *GrantODataServiceAccessStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } -func (s *AlterProjectSecurityStatementContext) EnterRule(listener antlr.ParseTreeListener) { +func (s *GrantODataServiceAccessStatementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.EnterAlterProjectSecurityStatement(s) + listenerT.EnterGrantODataServiceAccessStatement(s) } } -func (s *AlterProjectSecurityStatementContext) ExitRule(listener antlr.ParseTreeListener) { +func (s *GrantODataServiceAccessStatementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.ExitAlterProjectSecurityStatement(s) + listenerT.ExitGrantODataServiceAccessStatement(s) } } -func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecurityStatementContext) { - localctx = NewAlterProjectSecurityStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 66, MDLParserRULE_alterProjectSecurityStatement) - var _la int - - p.SetState(1299) - p.GetErrorHandler().Sync(p) - if p.HasError() { - goto errorExit - } - - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 60, p.GetParserRuleContext()) { - case 1: - p.EnterOuterAlt(localctx, 1) - { - p.SetState(1288) - p.Match(MDLParserALTER) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } +func (p *MDLParser) GrantODataServiceAccessStatement() (localctx IGrantODataServiceAccessStatementContext) { + localctx = NewGrantODataServiceAccessStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, MDLParserRULE_grantODataServiceAccessStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1330) + p.Match(MDLParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } - { - p.SetState(1289) - p.Match(MDLParserPROJECT) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + } + { + p.SetState(1331) + p.Match(MDLParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } - { - p.SetState(1290) - p.Match(MDLParserSECURITY) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + } + { + p.SetState(1332) + p.Match(MDLParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } - { - p.SetState(1291) - p.Match(MDLParserLEVEL) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + } + { + p.SetState(1333) + p.Match(MDLParserODATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } - { - p.SetState(1292) - _la = p.GetTokenStream().LA(1) - - if !((int64((_la-434)) & ^0x3f) == 0 && ((int64(1)<<(_la-434))&4099) != 0) { - p.GetErrorHandler().RecoverInline(p) + } + { + p.SetState(1334) + p.Match(MDLParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1335) + p.QualifiedName() + } + { + p.SetState(1336) + p.Match(MDLParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1337) + p.ModuleRoleList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevokeODataServiceAccessStatementContext is an interface to support dynamic dispatch. +type IRevokeODataServiceAccessStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + ACCESS() antlr.TerminalNode + ON() antlr.TerminalNode + ODATA() antlr.TerminalNode + SERVICE() antlr.TerminalNode + QualifiedName() IQualifiedNameContext + FROM() antlr.TerminalNode + ModuleRoleList() IModuleRoleListContext + + // IsRevokeODataServiceAccessStatementContext differentiates from other interfaces. + IsRevokeODataServiceAccessStatementContext() +} + +type RevokeODataServiceAccessStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevokeODataServiceAccessStatementContext() *RevokeODataServiceAccessStatementContext { + var p = new(RevokeODataServiceAccessStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_revokeODataServiceAccessStatement + return p +} + +func InitEmptyRevokeODataServiceAccessStatementContext(p *RevokeODataServiceAccessStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_revokeODataServiceAccessStatement +} + +func (*RevokeODataServiceAccessStatementContext) IsRevokeODataServiceAccessStatementContext() {} + +func NewRevokeODataServiceAccessStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeODataServiceAccessStatementContext { + var p = new(RevokeODataServiceAccessStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_revokeODataServiceAccessStatement + + return p +} + +func (s *RevokeODataServiceAccessStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *RevokeODataServiceAccessStatementContext) REVOKE() antlr.TerminalNode { + return s.GetToken(MDLParserREVOKE, 0) +} + +func (s *RevokeODataServiceAccessStatementContext) ACCESS() antlr.TerminalNode { + return s.GetToken(MDLParserACCESS, 0) +} + +func (s *RevokeODataServiceAccessStatementContext) ON() antlr.TerminalNode { + return s.GetToken(MDLParserON, 0) +} + +func (s *RevokeODataServiceAccessStatementContext) ODATA() antlr.TerminalNode { + return s.GetToken(MDLParserODATA, 0) +} + +func (s *RevokeODataServiceAccessStatementContext) SERVICE() antlr.TerminalNode { + return s.GetToken(MDLParserSERVICE, 0) +} + +func (s *RevokeODataServiceAccessStatementContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *RevokeODataServiceAccessStatementContext) FROM() antlr.TerminalNode { + return s.GetToken(MDLParserFROM, 0) +} + +func (s *RevokeODataServiceAccessStatementContext) ModuleRoleList() IModuleRoleListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModuleRoleListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModuleRoleListContext) +} + +func (s *RevokeODataServiceAccessStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokeODataServiceAccessStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RevokeODataServiceAccessStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterRevokeODataServiceAccessStatement(s) + } +} + +func (s *RevokeODataServiceAccessStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitRevokeODataServiceAccessStatement(s) + } +} + +func (p *MDLParser) RevokeODataServiceAccessStatement() (localctx IRevokeODataServiceAccessStatementContext) { + localctx = NewRevokeODataServiceAccessStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, MDLParserRULE_revokeODataServiceAccessStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1339) + p.Match(MDLParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1340) + p.Match(MDLParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1341) + p.Match(MDLParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1342) + p.Match(MDLParserODATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1343) + p.Match(MDLParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1344) + p.QualifiedName() + } + { + p.SetState(1345) + p.Match(MDLParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1346) + p.ModuleRoleList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterProjectSecurityStatementContext is an interface to support dynamic dispatch. +type IAlterProjectSecurityStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + PROJECT() antlr.TerminalNode + SECURITY() antlr.TerminalNode + LEVEL() antlr.TerminalNode + PRODUCTION() antlr.TerminalNode + PROTOTYPE() antlr.TerminalNode + OFF() antlr.TerminalNode + DEMO() antlr.TerminalNode + USERS() antlr.TerminalNode + ON() antlr.TerminalNode + + // IsAlterProjectSecurityStatementContext differentiates from other interfaces. + IsAlterProjectSecurityStatementContext() +} + +type AlterProjectSecurityStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterProjectSecurityStatementContext() *AlterProjectSecurityStatementContext { + var p = new(AlterProjectSecurityStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_alterProjectSecurityStatement + return p +} + +func InitEmptyAlterProjectSecurityStatementContext(p *AlterProjectSecurityStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_alterProjectSecurityStatement +} + +func (*AlterProjectSecurityStatementContext) IsAlterProjectSecurityStatementContext() {} + +func NewAlterProjectSecurityStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterProjectSecurityStatementContext { + var p = new(AlterProjectSecurityStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_alterProjectSecurityStatement + + return p +} + +func (s *AlterProjectSecurityStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterProjectSecurityStatementContext) ALTER() antlr.TerminalNode { + return s.GetToken(MDLParserALTER, 0) +} + +func (s *AlterProjectSecurityStatementContext) PROJECT() antlr.TerminalNode { + return s.GetToken(MDLParserPROJECT, 0) +} + +func (s *AlterProjectSecurityStatementContext) SECURITY() antlr.TerminalNode { + return s.GetToken(MDLParserSECURITY, 0) +} + +func (s *AlterProjectSecurityStatementContext) LEVEL() antlr.TerminalNode { + return s.GetToken(MDLParserLEVEL, 0) +} + +func (s *AlterProjectSecurityStatementContext) PRODUCTION() antlr.TerminalNode { + return s.GetToken(MDLParserPRODUCTION, 0) +} + +func (s *AlterProjectSecurityStatementContext) PROTOTYPE() antlr.TerminalNode { + return s.GetToken(MDLParserPROTOTYPE, 0) +} + +func (s *AlterProjectSecurityStatementContext) OFF() antlr.TerminalNode { + return s.GetToken(MDLParserOFF, 0) +} + +func (s *AlterProjectSecurityStatementContext) DEMO() antlr.TerminalNode { + return s.GetToken(MDLParserDEMO, 0) +} + +func (s *AlterProjectSecurityStatementContext) USERS() antlr.TerminalNode { + return s.GetToken(MDLParserUSERS, 0) +} + +func (s *AlterProjectSecurityStatementContext) ON() antlr.TerminalNode { + return s.GetToken(MDLParserON, 0) +} + +func (s *AlterProjectSecurityStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterProjectSecurityStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterProjectSecurityStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterAlterProjectSecurityStatement(s) + } +} + +func (s *AlterProjectSecurityStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitAlterProjectSecurityStatement(s) + } +} + +func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecurityStatementContext) { + localctx = NewAlterProjectSecurityStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, MDLParserRULE_alterProjectSecurityStatement) + var _la int + + p.SetState(1359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 60, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1348) + p.Match(MDLParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1349) + p.Match(MDLParserPROJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1350) + p.Match(MDLParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1351) + p.Match(MDLParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1352) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-435)) & ^0x3f) == 0 && ((int64(1)<<(_la-435))&4294967299) != 0) { + p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() @@ -13956,7 +14714,7 @@ func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecur case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1293) + p.SetState(1353) p.Match(MDLParserALTER) if p.HasError() { // Recognition error - abort rule @@ -13964,7 +14722,7 @@ func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecur } } { - p.SetState(1294) + p.SetState(1354) p.Match(MDLParserPROJECT) if p.HasError() { // Recognition error - abort rule @@ -13972,7 +14730,7 @@ func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecur } } { - p.SetState(1295) + p.SetState(1355) p.Match(MDLParserSECURITY) if p.HasError() { // Recognition error - abort rule @@ -13980,7 +14738,7 @@ func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecur } } { - p.SetState(1296) + p.SetState(1356) p.Match(MDLParserDEMO) if p.HasError() { // Recognition error - abort rule @@ -13988,7 +14746,7 @@ func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecur } } { - p.SetState(1297) + p.SetState(1357) p.Match(MDLParserUSERS) if p.HasError() { // Recognition error - abort rule @@ -13996,7 +14754,7 @@ func (p *MDLParser) AlterProjectSecurityStatement() (localctx IAlterProjectSecur } } { - p.SetState(1298) + p.SetState(1358) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserON || _la == MDLParserOFF) { @@ -14042,6 +14800,8 @@ type ICreateDemoUserStatementContext interface { AllIdentifierOrKeyword() []IIdentifierOrKeywordContext IdentifierOrKeyword(i int) IIdentifierOrKeywordContext RPAREN() antlr.TerminalNode + ENTITY() antlr.TerminalNode + QualifiedName() IQualifiedNameContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode @@ -14154,6 +14914,26 @@ func (s *CreateDemoUserStatementContext) RPAREN() antlr.TerminalNode { return s.GetToken(MDLParserRPAREN, 0) } +func (s *CreateDemoUserStatementContext) ENTITY() antlr.TerminalNode { + return s.GetToken(MDLParserENTITY, 0) +} + +func (s *CreateDemoUserStatementContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + func (s *CreateDemoUserStatementContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(MDLParserCOMMA) } @@ -14184,12 +14964,12 @@ func (s *CreateDemoUserStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatementContext) { localctx = NewCreateDemoUserStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 68, MDLParserRULE_createDemoUserStatement) + p.EnterRule(localctx, 72, MDLParserRULE_createDemoUserStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1301) + p.SetState(1361) p.Match(MDLParserCREATE) if p.HasError() { // Recognition error - abort rule @@ -14197,7 +14977,7 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement } } { - p.SetState(1302) + p.SetState(1362) p.Match(MDLParserDEMO) if p.HasError() { // Recognition error - abort rule @@ -14205,7 +14985,7 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement } } { - p.SetState(1303) + p.SetState(1363) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -14213,7 +14993,7 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement } } { - p.SetState(1304) + p.SetState(1364) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -14221,7 +15001,7 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement } } { - p.SetState(1305) + p.SetState(1365) p.Match(MDLParserPASSWORD) if p.HasError() { // Recognition error - abort rule @@ -14229,15 +15009,37 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement } } { - p.SetState(1306) + p.SetState(1366) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } + p.SetState(1369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserENTITY { + { + p.SetState(1367) + p.Match(MDLParserENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1368) + p.QualifiedName() + } + + } { - p.SetState(1307) + p.SetState(1371) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -14245,10 +15047,10 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement } } { - p.SetState(1308) + p.SetState(1372) p.IdentifierOrKeyword() } - p.SetState(1313) + p.SetState(1377) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14257,7 +15059,7 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement for _la == MDLParserCOMMA { { - p.SetState(1309) + p.SetState(1373) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -14265,11 +15067,11 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement } } { - p.SetState(1310) + p.SetState(1374) p.IdentifierOrKeyword() } - p.SetState(1315) + p.SetState(1379) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14277,7 +15079,7 @@ func (p *MDLParser) CreateDemoUserStatement() (localctx ICreateDemoUserStatement _la = p.GetTokenStream().LA(1) } { - p.SetState(1316) + p.SetState(1380) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -14385,10 +15187,10 @@ func (s *DropDemoUserStatementContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) DropDemoUserStatement() (localctx IDropDemoUserStatementContext) { localctx = NewDropDemoUserStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 70, MDLParserRULE_dropDemoUserStatement) + p.EnterRule(localctx, 74, MDLParserRULE_dropDemoUserStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1318) + p.SetState(1382) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -14396,7 +15198,7 @@ func (p *MDLParser) DropDemoUserStatement() (localctx IDropDemoUserStatementCont } } { - p.SetState(1319) + p.SetState(1383) p.Match(MDLParserDEMO) if p.HasError() { // Recognition error - abort rule @@ -14404,7 +15206,7 @@ func (p *MDLParser) DropDemoUserStatement() (localctx IDropDemoUserStatementCont } } { - p.SetState(1320) + p.SetState(1384) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -14412,7 +15214,7 @@ func (p *MDLParser) DropDemoUserStatement() (localctx IDropDemoUserStatementCont } } { - p.SetState(1321) + p.SetState(1385) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -14532,12 +15334,12 @@ func (s *UpdateSecurityStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) UpdateSecurityStatement() (localctx IUpdateSecurityStatementContext) { localctx = NewUpdateSecurityStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 72, MDLParserRULE_updateSecurityStatement) + p.EnterRule(localctx, 76, MDLParserRULE_updateSecurityStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1323) + p.SetState(1387) p.Match(MDLParserUPDATE) if p.HasError() { // Recognition error - abort rule @@ -14545,14 +15347,14 @@ func (p *MDLParser) UpdateSecurityStatement() (localctx IUpdateSecurityStatement } } { - p.SetState(1324) + p.SetState(1388) p.Match(MDLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1327) + p.SetState(1391) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14561,7 +15363,7 @@ func (p *MDLParser) UpdateSecurityStatement() (localctx IUpdateSecurityStatement if _la == MDLParserIN { { - p.SetState(1325) + p.SetState(1389) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule @@ -14569,7 +15371,7 @@ func (p *MDLParser) UpdateSecurityStatement() (localctx IUpdateSecurityStatement } } { - p.SetState(1326) + p.SetState(1390) p.QualifiedName() } @@ -14708,15 +15510,15 @@ func (s *ModuleRoleListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ModuleRoleList() (localctx IModuleRoleListContext) { localctx = NewModuleRoleListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 74, MDLParserRULE_moduleRoleList) + p.EnterRule(localctx, 78, MDLParserRULE_moduleRoleList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1329) + p.SetState(1393) p.QualifiedName() } - p.SetState(1334) + p.SetState(1398) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14725,7 +15527,7 @@ func (p *MDLParser) ModuleRoleList() (localctx IModuleRoleListContext) { for _la == MDLParserCOMMA { { - p.SetState(1330) + p.SetState(1394) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -14733,11 +15535,11 @@ func (p *MDLParser) ModuleRoleList() (localctx IModuleRoleListContext) { } } { - p.SetState(1331) + p.SetState(1395) p.QualifiedName() } - p.SetState(1336) + p.SetState(1400) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14878,15 +15680,15 @@ func (s *EntityAccessRightListContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) EntityAccessRightList() (localctx IEntityAccessRightListContext) { localctx = NewEntityAccessRightListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 76, MDLParserRULE_entityAccessRightList) + p.EnterRule(localctx, 80, MDLParserRULE_entityAccessRightList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1337) + p.SetState(1401) p.EntityAccessRight() } - p.SetState(1342) + p.SetState(1406) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14895,7 +15697,7 @@ func (p *MDLParser) EntityAccessRightList() (localctx IEntityAccessRightListCont for _la == MDLParserCOMMA { { - p.SetState(1338) + p.SetState(1402) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -14903,11 +15705,11 @@ func (p *MDLParser) EntityAccessRightList() (localctx IEntityAccessRightListCont } } { - p.SetState(1339) + p.SetState(1403) p.EntityAccessRight() } - p.SetState(1344) + p.SetState(1408) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15050,20 +15852,20 @@ func (s *EntityAccessRightContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { localctx = NewEntityAccessRightContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 78, MDLParserRULE_entityAccessRight) + p.EnterRule(localctx, 82, MDLParserRULE_entityAccessRight) var _la int - p.SetState(1373) + p.SetState(1437) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 67, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 68, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1345) + p.SetState(1409) p.Match(MDLParserCREATE) if p.HasError() { // Recognition error - abort rule @@ -15074,7 +15876,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1346) + p.SetState(1410) p.Match(MDLParserDELETE) if p.HasError() { // Recognition error - abort rule @@ -15085,7 +15887,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1347) + p.SetState(1411) p.Match(MDLParserREAD) if p.HasError() { // Recognition error - abort rule @@ -15093,7 +15895,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1348) + p.SetState(1412) p.Match(MDLParserSTAR) if p.HasError() { // Recognition error - abort rule @@ -15104,7 +15906,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1349) + p.SetState(1413) p.Match(MDLParserREAD) if p.HasError() { // Recognition error - abort rule @@ -15112,7 +15914,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1350) + p.SetState(1414) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -15120,14 +15922,14 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1351) + p.SetState(1415) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1356) + p.SetState(1420) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15136,7 +15938,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { for _la == MDLParserCOMMA { { - p.SetState(1352) + p.SetState(1416) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -15144,7 +15946,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1353) + p.SetState(1417) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -15152,7 +15954,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } - p.SetState(1358) + p.SetState(1422) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15160,7 +15962,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1359) + p.SetState(1423) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -15171,7 +15973,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1360) + p.SetState(1424) p.Match(MDLParserWRITE) if p.HasError() { // Recognition error - abort rule @@ -15179,7 +15981,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1361) + p.SetState(1425) p.Match(MDLParserSTAR) if p.HasError() { // Recognition error - abort rule @@ -15190,7 +15992,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1362) + p.SetState(1426) p.Match(MDLParserWRITE) if p.HasError() { // Recognition error - abort rule @@ -15198,7 +16000,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1363) + p.SetState(1427) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -15206,14 +16008,14 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1364) + p.SetState(1428) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1369) + p.SetState(1433) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15222,7 +16024,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { for _la == MDLParserCOMMA { { - p.SetState(1365) + p.SetState(1429) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -15230,7 +16032,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } { - p.SetState(1366) + p.SetState(1430) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -15238,7 +16040,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { } } - p.SetState(1371) + p.SetState(1435) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15246,7 +16048,7 @@ func (p *MDLParser) EntityAccessRight() (localctx IEntityAccessRightContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1372) + p.SetState(1436) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -15446,10 +16248,10 @@ func (s *CreateEntityStatementContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementContext) { localctx = NewCreateEntityStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 80, MDLParserRULE_createEntityStatement) + p.EnterRule(localctx, 84, MDLParserRULE_createEntityStatement) var _la int - p.SetState(1421) + p.SetState(1485) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15459,7 +16261,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont case MDLParserPERSISTENT: p.EnterOuterAlt(localctx, 1) { - p.SetState(1375) + p.SetState(1439) p.Match(MDLParserPERSISTENT) if p.HasError() { // Recognition error - abort rule @@ -15467,7 +16269,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1376) + p.SetState(1440) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -15475,10 +16277,10 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1377) + p.SetState(1441) p.QualifiedName() } - p.SetState(1379) + p.SetState(1443) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15487,12 +16289,12 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserGENERALIZATION || _la == MDLParserEXTENDS { { - p.SetState(1378) + p.SetState(1442) p.GeneralizationClause() } } - p.SetState(1382) + p.SetState(1446) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15501,7 +16303,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserINDEX || _la == MDLParserCOMMENT || _la == MDLParserLPAREN { { - p.SetState(1381) + p.SetState(1445) p.EntityBody() } @@ -15510,7 +16312,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont case MDLParserNON_PERSISTENT: p.EnterOuterAlt(localctx, 2) { - p.SetState(1384) + p.SetState(1448) p.Match(MDLParserNON_PERSISTENT) if p.HasError() { // Recognition error - abort rule @@ -15518,7 +16320,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1385) + p.SetState(1449) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -15526,10 +16328,10 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1386) + p.SetState(1450) p.QualifiedName() } - p.SetState(1388) + p.SetState(1452) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15538,12 +16340,12 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserGENERALIZATION || _la == MDLParserEXTENDS { { - p.SetState(1387) + p.SetState(1451) p.GeneralizationClause() } } - p.SetState(1391) + p.SetState(1455) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15552,7 +16354,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserINDEX || _la == MDLParserCOMMENT || _la == MDLParserLPAREN { { - p.SetState(1390) + p.SetState(1454) p.EntityBody() } @@ -15561,7 +16363,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont case MDLParserVIEW: p.EnterOuterAlt(localctx, 3) { - p.SetState(1393) + p.SetState(1457) p.Match(MDLParserVIEW) if p.HasError() { // Recognition error - abort rule @@ -15569,7 +16371,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1394) + p.SetState(1458) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -15577,10 +16379,10 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1395) + p.SetState(1459) p.QualifiedName() } - p.SetState(1397) + p.SetState(1461) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15589,20 +16391,20 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserINDEX || _la == MDLParserCOMMENT || _la == MDLParserLPAREN { { - p.SetState(1396) + p.SetState(1460) p.EntityBody() } } { - p.SetState(1399) + p.SetState(1463) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1401) + p.SetState(1465) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15611,7 +16413,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserLPAREN { { - p.SetState(1400) + p.SetState(1464) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -15621,10 +16423,10 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } { - p.SetState(1403) + p.SetState(1467) p.OqlQuery() } - p.SetState(1405) + p.SetState(1469) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15633,7 +16435,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserRPAREN { { - p.SetState(1404) + p.SetState(1468) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -15646,7 +16448,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont case MDLParserEXTERNAL: p.EnterOuterAlt(localctx, 4) { - p.SetState(1407) + p.SetState(1471) p.Match(MDLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule @@ -15654,7 +16456,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1408) + p.SetState(1472) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -15662,10 +16464,10 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1409) + p.SetState(1473) p.QualifiedName() } - p.SetState(1411) + p.SetState(1475) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15674,7 +16476,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserINDEX || _la == MDLParserCOMMENT || _la == MDLParserLPAREN { { - p.SetState(1410) + p.SetState(1474) p.EntityBody() } @@ -15683,7 +16485,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont case MDLParserENTITY: p.EnterOuterAlt(localctx, 5) { - p.SetState(1413) + p.SetState(1477) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -15691,10 +16493,10 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont } } { - p.SetState(1414) + p.SetState(1478) p.QualifiedName() } - p.SetState(1416) + p.SetState(1480) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15703,12 +16505,12 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserGENERALIZATION || _la == MDLParserEXTENDS { { - p.SetState(1415) + p.SetState(1479) p.GeneralizationClause() } } - p.SetState(1419) + p.SetState(1483) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15717,7 +16519,7 @@ func (p *MDLParser) CreateEntityStatement() (localctx ICreateEntityStatementCont if _la == MDLParserINDEX || _la == MDLParserCOMMENT || _la == MDLParserLPAREN { { - p.SetState(1418) + p.SetState(1482) p.EntityBody() } @@ -15835,8 +16637,8 @@ func (s *GeneralizationClauseContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) GeneralizationClause() (localctx IGeneralizationClauseContext) { localctx = NewGeneralizationClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 82, MDLParserRULE_generalizationClause) - p.SetState(1427) + p.EnterRule(localctx, 86, MDLParserRULE_generalizationClause) + p.SetState(1491) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15846,7 +16648,7 @@ func (p *MDLParser) GeneralizationClause() (localctx IGeneralizationClauseContex case MDLParserEXTENDS: p.EnterOuterAlt(localctx, 1) { - p.SetState(1423) + p.SetState(1487) p.Match(MDLParserEXTENDS) if p.HasError() { // Recognition error - abort rule @@ -15854,14 +16656,14 @@ func (p *MDLParser) GeneralizationClause() (localctx IGeneralizationClauseContex } } { - p.SetState(1424) + p.SetState(1488) p.QualifiedName() } case MDLParserGENERALIZATION: p.EnterOuterAlt(localctx, 2) { - p.SetState(1425) + p.SetState(1489) p.Match(MDLParserGENERALIZATION) if p.HasError() { // Recognition error - abort rule @@ -15869,7 +16671,7 @@ func (p *MDLParser) GeneralizationClause() (localctx IGeneralizationClauseContex } } { - p.SetState(1426) + p.SetState(1490) p.QualifiedName() } @@ -16002,10 +16804,10 @@ func (s *EntityBodyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EntityBody() (localctx IEntityBodyContext) { localctx = NewEntityBodyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 84, MDLParserRULE_entityBody) + p.EnterRule(localctx, 88, MDLParserRULE_entityBody) var _la int - p.SetState(1438) + p.SetState(1502) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16015,36 +16817,36 @@ func (p *MDLParser) EntityBody() (localctx IEntityBodyContext) { case MDLParserLPAREN: p.EnterOuterAlt(localctx, 1) { - p.SetState(1429) + p.SetState(1493) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1431) + p.SetState(1495) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&12681767114768388) != 0) || ((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&18084767253659649) != 0) || ((int64((_la-133)) & ^0x3f) == 0 && ((int64(1)<<(_la-133))&2819253375860736011) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&549772630787) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-471)) & ^0x3f) == 0 && ((int64(1)<<(_la-471))&10241) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&12681767114768388) != 0) || ((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&18084767253659649) != 0) || ((int64((_la-133)) & ^0x3f) == 0 && ((int64(1)<<(_la-133))&2819253375860736011) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&549772630787) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-492)) & ^0x3f) == 0 && ((int64(1)<<(_la-492))&10241) != 0) { { - p.SetState(1430) + p.SetState(1494) p.AttributeDefinitionList() } } { - p.SetState(1433) + p.SetState(1497) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1435) + p.SetState(1499) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16053,7 +16855,7 @@ func (p *MDLParser) EntityBody() (localctx IEntityBodyContext) { if _la == MDLParserINDEX || _la == MDLParserCOMMENT { { - p.SetState(1434) + p.SetState(1498) p.EntityOptions() } @@ -16062,7 +16864,7 @@ func (p *MDLParser) EntityBody() (localctx IEntityBodyContext) { case MDLParserINDEX, MDLParserCOMMENT: p.EnterOuterAlt(localctx, 2) { - p.SetState(1437) + p.SetState(1501) p.EntityOptions() } @@ -16204,15 +17006,15 @@ func (s *EntityOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EntityOptions() (localctx IEntityOptionsContext) { localctx = NewEntityOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 86, MDLParserRULE_entityOptions) + p.EnterRule(localctx, 90, MDLParserRULE_entityOptions) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1440) + p.SetState(1504) p.EntityOption() } - p.SetState(1447) + p.SetState(1511) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16220,7 +17022,7 @@ func (p *MDLParser) EntityOptions() (localctx IEntityOptionsContext) { _la = p.GetTokenStream().LA(1) for _la == MDLParserINDEX || _la == MDLParserCOMMENT || _la == MDLParserCOMMA { - p.SetState(1442) + p.SetState(1506) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16229,7 +17031,7 @@ func (p *MDLParser) EntityOptions() (localctx IEntityOptionsContext) { if _la == MDLParserCOMMA { { - p.SetState(1441) + p.SetState(1505) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -16239,11 +17041,11 @@ func (p *MDLParser) EntityOptions() (localctx IEntityOptionsContext) { } { - p.SetState(1444) + p.SetState(1508) p.EntityOption() } - p.SetState(1449) + p.SetState(1513) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16363,8 +17165,8 @@ func (s *EntityOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EntityOption() (localctx IEntityOptionContext) { localctx = NewEntityOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 88, MDLParserRULE_entityOption) - p.SetState(1454) + p.EnterRule(localctx, 92, MDLParserRULE_entityOption) + p.SetState(1518) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16374,7 +17176,7 @@ func (p *MDLParser) EntityOption() (localctx IEntityOptionContext) { case MDLParserCOMMENT: p.EnterOuterAlt(localctx, 1) { - p.SetState(1450) + p.SetState(1514) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -16382,7 +17184,7 @@ func (p *MDLParser) EntityOption() (localctx IEntityOptionContext) { } } { - p.SetState(1451) + p.SetState(1515) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -16393,7 +17195,7 @@ func (p *MDLParser) EntityOption() (localctx IEntityOptionContext) { case MDLParserINDEX: p.EnterOuterAlt(localctx, 2) { - p.SetState(1452) + p.SetState(1516) p.Match(MDLParserINDEX) if p.HasError() { // Recognition error - abort rule @@ -16401,7 +17203,7 @@ func (p *MDLParser) EntityOption() (localctx IEntityOptionContext) { } } { - p.SetState(1453) + p.SetState(1517) p.IndexDefinition() } @@ -16543,15 +17345,15 @@ func (s *AttributeDefinitionListContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) AttributeDefinitionList() (localctx IAttributeDefinitionListContext) { localctx = NewAttributeDefinitionListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 90, MDLParserRULE_attributeDefinitionList) + p.EnterRule(localctx, 94, MDLParserRULE_attributeDefinitionList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1456) + p.SetState(1520) p.AttributeDefinition() } - p.SetState(1461) + p.SetState(1525) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16560,7 +17362,7 @@ func (p *MDLParser) AttributeDefinitionList() (localctx IAttributeDefinitionList for _la == MDLParserCOMMA { { - p.SetState(1457) + p.SetState(1521) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -16568,11 +17370,11 @@ func (p *MDLParser) AttributeDefinitionList() (localctx IAttributeDefinitionList } } { - p.SetState(1458) + p.SetState(1522) p.AttributeDefinition() } - p.SetState(1463) + p.SetState(1527) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16802,11 +17604,11 @@ func (s *AttributeDefinitionContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) AttributeDefinition() (localctx IAttributeDefinitionContext) { localctx = NewAttributeDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 92, MDLParserRULE_attributeDefinition) + p.EnterRule(localctx, 96, MDLParserRULE_attributeDefinition) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1465) + p.SetState(1529) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16815,12 +17617,12 @@ func (p *MDLParser) AttributeDefinition() (localctx IAttributeDefinitionContext) if _la == MDLParserDOC_COMMENT { { - p.SetState(1464) + p.SetState(1528) p.DocComment() } } - p.SetState(1470) + p.SetState(1534) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16829,11 +17631,11 @@ func (p *MDLParser) AttributeDefinition() (localctx IAttributeDefinitionContext) for _la == MDLParserAT { { - p.SetState(1467) + p.SetState(1531) p.Annotation() } - p.SetState(1472) + p.SetState(1536) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16841,11 +17643,11 @@ func (p *MDLParser) AttributeDefinition() (localctx IAttributeDefinitionContext) _la = p.GetTokenStream().LA(1) } { - p.SetState(1473) + p.SetState(1537) p.AttributeName() } { - p.SetState(1474) + p.SetState(1538) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -16853,23 +17655,23 @@ func (p *MDLParser) AttributeDefinition() (localctx IAttributeDefinitionContext) } } { - p.SetState(1475) + p.SetState(1539) p.DataType() } - p.SetState(1479) + p.SetState(1543) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for _la == MDLParserNOT_NULL || ((int64((_la-282)) & ^0x3f) == 0 && ((int64(1)<<(_la-282))&16769) != 0) { + for _la == MDLParserNOT_NULL || ((int64((_la-282)) & ^0x3f) == 0 && ((int64(1)<<(_la-282))&8405377) != 0) { { - p.SetState(1476) + p.SetState(1540) p.AttributeConstraint() } - p.SetState(1481) + p.SetState(1545) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16984,8 +17786,8 @@ func (s *AttributeNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AttributeName() (localctx IAttributeNameContext) { localctx = NewAttributeNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 94, MDLParserRULE_attributeName) - p.SetState(1485) + p.EnterRule(localctx, 98, MDLParserRULE_attributeName) + p.SetState(1549) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16995,7 +17797,7 @@ func (p *MDLParser) AttributeName() (localctx IAttributeNameContext) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(1482) + p.SetState(1546) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -17006,7 +17808,7 @@ func (p *MDLParser) AttributeName() (localctx IAttributeNameContext) { case MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(1483) + p.SetState(1547) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -17017,7 +17819,7 @@ func (p *MDLParser) AttributeName() (localctx IAttributeNameContext) { case MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserDEBUG, MDLParserACTION, MDLParserSORT, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserTITLE, MDLParserLABEL, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserEDITABLE, MDLParserVISIBLE, MDLParserSUCCESS, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserERROR, MDLParserRANGE, MDLParserSTATUS, MDLParserVERSION, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserNAVIGATION, MDLParserHOME, MDLParserCHECK, MDLParserTEXT, MDLParserMESSAGE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserFORMAT, MDLParserROLE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserDESCRIPTION, MDLParserOFF: p.EnterOuterAlt(localctx, 3) { - p.SetState(1484) + p.SetState(1548) p.CommonNameKeyword() } @@ -17057,6 +17859,9 @@ type IAttributeConstraintContext interface { Literal() ILiteralContext Expression() IExpressionContext REQUIRED() antlr.TerminalNode + CALCULATED() antlr.TerminalNode + QualifiedName() IQualifiedNameContext + BY() antlr.TerminalNode // IsAttributeConstraintContext differentiates from other interfaces. IsAttributeConstraintContext() @@ -17158,6 +17963,30 @@ func (s *AttributeConstraintContext) REQUIRED() antlr.TerminalNode { return s.GetToken(MDLParserREQUIRED, 0) } +func (s *AttributeConstraintContext) CALCULATED() antlr.TerminalNode { + return s.GetToken(MDLParserCALCULATED, 0) +} + +func (s *AttributeConstraintContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *AttributeConstraintContext) BY() antlr.TerminalNode { + return s.GetToken(MDLParserBY, 0) +} + func (s *AttributeConstraintContext) GetRuleContext() antlr.RuleContext { return s } @@ -17180,10 +18009,10 @@ func (s *AttributeConstraintContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) { localctx = NewAttributeConstraintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 96, MDLParserRULE_attributeConstraint) + p.EnterRule(localctx, 100, MDLParserRULE_attributeConstraint) var _la int - p.SetState(1513) + p.SetState(1584) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17193,14 +18022,14 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) case MDLParserNOT_NULL: p.EnterOuterAlt(localctx, 1) { - p.SetState(1487) + p.SetState(1551) p.Match(MDLParserNOT_NULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1490) + p.SetState(1554) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17209,7 +18038,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) if _la == MDLParserERROR { { - p.SetState(1488) + p.SetState(1552) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -17217,7 +18046,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) } } { - p.SetState(1489) + p.SetState(1553) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -17230,7 +18059,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) case MDLParserNOT: p.EnterOuterAlt(localctx, 2) { - p.SetState(1492) + p.SetState(1556) p.Match(MDLParserNOT) if p.HasError() { // Recognition error - abort rule @@ -17238,14 +18067,14 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) } } { - p.SetState(1493) + p.SetState(1557) p.Match(MDLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1496) + p.SetState(1560) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17254,7 +18083,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) if _la == MDLParserERROR { { - p.SetState(1494) + p.SetState(1558) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -17262,7 +18091,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) } } { - p.SetState(1495) + p.SetState(1559) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -17275,14 +18104,14 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) case MDLParserUNIQUE: p.EnterOuterAlt(localctx, 3) { - p.SetState(1498) + p.SetState(1562) p.Match(MDLParserUNIQUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1501) + p.SetState(1565) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17291,7 +18120,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) if _la == MDLParserERROR { { - p.SetState(1499) + p.SetState(1563) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -17299,7 +18128,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) } } { - p.SetState(1500) + p.SetState(1564) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -17312,29 +18141,29 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) case MDLParserDEFAULT: p.EnterOuterAlt(localctx, 4) { - p.SetState(1503) + p.SetState(1567) p.Match(MDLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1506) + p.SetState(1570) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 94, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 95, p.GetParserRuleContext()) { case 1: { - p.SetState(1504) + p.SetState(1568) p.Literal() } case 2: { - p.SetState(1505) + p.SetState(1569) p.Expression() } @@ -17345,14 +18174,14 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) case MDLParserREQUIRED: p.EnterOuterAlt(localctx, 5) { - p.SetState(1508) + p.SetState(1572) p.Match(MDLParserREQUIRED) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1511) + p.SetState(1575) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17361,7 +18190,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) if _la == MDLParserERROR { { - p.SetState(1509) + p.SetState(1573) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -17369,7 +18198,7 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) } } { - p.SetState(1510) + p.SetState(1574) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -17379,6 +18208,45 @@ func (p *MDLParser) AttributeConstraint() (localctx IAttributeConstraintContext) } + case MDLParserCALCULATED: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1577) + p.Match(MDLParserCALCULATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 98, p.GetParserRuleContext()) == 1 { + p.SetState(1579) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 97, p.GetParserRuleContext()) == 1 { + { + p.SetState(1578) + p.Match(MDLParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1581) + p.QualifiedName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit @@ -17613,27 +18481,27 @@ func (s *DataTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DataType() (localctx IDataTypeContext) { localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 98, MDLParserRULE_dataType) + p.EnterRule(localctx, 102, MDLParserRULE_dataType) var _la int - p.SetState(1551) + p.SetState(1622) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 98, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 101, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1515) + p.SetState(1586) p.Match(MDLParserSTRING_TYPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1519) + p.SetState(1590) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17642,7 +18510,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { if _la == MDLParserLPAREN { { - p.SetState(1516) + p.SetState(1587) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -17650,7 +18518,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1517) + p.SetState(1588) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -17658,7 +18526,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1518) + p.SetState(1589) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -17671,7 +18539,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1521) + p.SetState(1592) p.Match(MDLParserINTEGER_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17682,7 +18550,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1522) + p.SetState(1593) p.Match(MDLParserLONG_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17693,7 +18561,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1523) + p.SetState(1594) p.Match(MDLParserDECIMAL_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17704,7 +18572,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1524) + p.SetState(1595) p.Match(MDLParserBOOLEAN_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17715,7 +18583,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1525) + p.SetState(1596) p.Match(MDLParserDATETIME_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17726,7 +18594,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(1526) + p.SetState(1597) p.Match(MDLParserDATE_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17737,7 +18605,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(1527) + p.SetState(1598) p.Match(MDLParserAUTONUMBER_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17748,7 +18616,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(1528) + p.SetState(1599) p.Match(MDLParserBINARY_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17759,7 +18627,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(1529) + p.SetState(1600) p.Match(MDLParserHASHEDSTRING_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17770,7 +18638,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(1530) + p.SetState(1601) p.Match(MDLParserCURRENCY_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17781,7 +18649,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(1531) + p.SetState(1602) p.Match(MDLParserFLOAT_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17792,7 +18660,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(1532) + p.SetState(1603) p.Match(MDLParserSTRINGTEMPLATE_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17800,7 +18668,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1533) + p.SetState(1604) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -17808,11 +18676,11 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1534) + p.SetState(1605) p.TemplateContext() } { - p.SetState(1535) + p.SetState(1606) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -17823,7 +18691,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(1537) + p.SetState(1608) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -17831,7 +18699,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1538) + p.SetState(1609) p.Match(MDLParserLESS_THAN) if p.HasError() { // Recognition error - abort rule @@ -17839,7 +18707,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1539) + p.SetState(1610) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -17847,7 +18715,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1540) + p.SetState(1611) p.Match(MDLParserGREATER_THAN) if p.HasError() { // Recognition error - abort rule @@ -17858,7 +18726,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(1541) + p.SetState(1612) p.Match(MDLParserENUM_TYPE) if p.HasError() { // Recognition error - abort rule @@ -17866,14 +18734,14 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1542) + p.SetState(1613) p.QualifiedName() } case 16: p.EnterOuterAlt(localctx, 16) { - p.SetState(1543) + p.SetState(1614) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -17881,7 +18749,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1544) + p.SetState(1615) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -17889,11 +18757,11 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1545) + p.SetState(1616) p.QualifiedName() } { - p.SetState(1546) + p.SetState(1617) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -17904,7 +18772,7 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { case 17: p.EnterOuterAlt(localctx, 17) { - p.SetState(1548) + p.SetState(1619) p.Match(MDLParserLIST_OF) if p.HasError() { // Recognition error - abort rule @@ -17912,14 +18780,14 @@ func (p *MDLParser) DataType() (localctx IDataTypeContext) { } } { - p.SetState(1549) + p.SetState(1620) p.QualifiedName() } case 18: p.EnterOuterAlt(localctx, 18) { - p.SetState(1550) + p.SetState(1621) p.QualifiedName() } @@ -18017,12 +18885,12 @@ func (s *TemplateContextContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) TemplateContext() (localctx ITemplateContextContext) { localctx = NewTemplateContextContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 100, MDLParserRULE_templateContext) + p.EnterRule(localctx, 104, MDLParserRULE_templateContext) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1553) + p.SetState(1624) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserTEXT || _la == MDLParserSQL) { @@ -18215,30 +19083,30 @@ func (s *NonListDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { localctx = NewNonListDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 102, MDLParserRULE_nonListDataType) - p.SetState(1580) + p.EnterRule(localctx, 106, MDLParserRULE_nonListDataType) + p.SetState(1651) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 100, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 103, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1555) + p.SetState(1626) p.Match(MDLParserSTRING_TYPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1559) + p.SetState(1630) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 { { - p.SetState(1556) + p.SetState(1627) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -18246,7 +19114,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { } } { - p.SetState(1557) + p.SetState(1628) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -18254,7 +19122,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { } } { - p.SetState(1558) + p.SetState(1629) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -18269,7 +19137,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1561) + p.SetState(1632) p.Match(MDLParserINTEGER_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18280,7 +19148,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1562) + p.SetState(1633) p.Match(MDLParserLONG_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18291,7 +19159,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1563) + p.SetState(1634) p.Match(MDLParserDECIMAL_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18302,7 +19170,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1564) + p.SetState(1635) p.Match(MDLParserBOOLEAN_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18313,7 +19181,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1565) + p.SetState(1636) p.Match(MDLParserDATETIME_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18324,7 +19192,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(1566) + p.SetState(1637) p.Match(MDLParserDATE_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18335,7 +19203,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(1567) + p.SetState(1638) p.Match(MDLParserAUTONUMBER_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18346,7 +19214,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(1568) + p.SetState(1639) p.Match(MDLParserBINARY_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18357,7 +19225,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(1569) + p.SetState(1640) p.Match(MDLParserHASHEDSTRING_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18368,7 +19236,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(1570) + p.SetState(1641) p.Match(MDLParserCURRENCY_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18379,7 +19247,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(1571) + p.SetState(1642) p.Match(MDLParserFLOAT_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18390,7 +19258,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(1572) + p.SetState(1643) p.Match(MDLParserENUM_TYPE) if p.HasError() { // Recognition error - abort rule @@ -18398,14 +19266,14 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { } } { - p.SetState(1573) + p.SetState(1644) p.QualifiedName() } case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(1574) + p.SetState(1645) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -18413,7 +19281,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { } } { - p.SetState(1575) + p.SetState(1646) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -18421,11 +19289,11 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { } } { - p.SetState(1576) + p.SetState(1647) p.QualifiedName() } { - p.SetState(1577) + p.SetState(1648) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -18436,7 +19304,7 @@ func (p *MDLParser) NonListDataType() (localctx INonListDataTypeContext) { case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(1579) + p.SetState(1650) p.QualifiedName() } @@ -18556,11 +19424,11 @@ func (s *IndexDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) IndexDefinition() (localctx IIndexDefinitionContext) { localctx = NewIndexDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 104, MDLParserRULE_indexDefinition) + p.EnterRule(localctx, 108, MDLParserRULE_indexDefinition) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1583) + p.SetState(1654) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18569,7 +19437,7 @@ func (p *MDLParser) IndexDefinition() (localctx IIndexDefinitionContext) { if _la == MDLParserIDENTIFIER { { - p.SetState(1582) + p.SetState(1653) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -18579,7 +19447,7 @@ func (p *MDLParser) IndexDefinition() (localctx IIndexDefinitionContext) { } { - p.SetState(1585) + p.SetState(1656) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -18587,11 +19455,11 @@ func (p *MDLParser) IndexDefinition() (localctx IIndexDefinitionContext) { } } { - p.SetState(1586) + p.SetState(1657) p.IndexAttributeList() } { - p.SetState(1587) + p.SetState(1658) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -18732,15 +19600,15 @@ func (s *IndexAttributeListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) IndexAttributeList() (localctx IIndexAttributeListContext) { localctx = NewIndexAttributeListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 106, MDLParserRULE_indexAttributeList) + p.EnterRule(localctx, 110, MDLParserRULE_indexAttributeList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1589) + p.SetState(1660) p.IndexAttribute() } - p.SetState(1594) + p.SetState(1665) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18749,7 +19617,7 @@ func (p *MDLParser) IndexAttributeList() (localctx IIndexAttributeListContext) { for _la == MDLParserCOMMA { { - p.SetState(1590) + p.SetState(1661) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -18757,11 +19625,11 @@ func (p *MDLParser) IndexAttributeList() (localctx IIndexAttributeListContext) { } } { - p.SetState(1591) + p.SetState(1662) p.IndexAttribute() } - p.SetState(1596) + p.SetState(1667) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18876,15 +19744,15 @@ func (s *IndexAttributeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) IndexAttribute() (localctx IIndexAttributeContext) { localctx = NewIndexAttributeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 108, MDLParserRULE_indexAttribute) + p.EnterRule(localctx, 112, MDLParserRULE_indexAttribute) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1597) + p.SetState(1668) p.IndexColumnName() } - p.SetState(1599) + p.SetState(1670) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18893,7 +19761,7 @@ func (p *MDLParser) IndexAttribute() (localctx IIndexAttributeContext) { if _la == MDLParserASC || _la == MDLParserDESC { { - p.SetState(1598) + p.SetState(1669) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserASC || _la == MDLParserDESC) { @@ -19013,8 +19881,8 @@ func (s *IndexColumnNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) IndexColumnName() (localctx IIndexColumnNameContext) { localctx = NewIndexColumnNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 110, MDLParserRULE_indexColumnName) - p.SetState(1604) + p.EnterRule(localctx, 114, MDLParserRULE_indexColumnName) + p.SetState(1675) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19024,7 +19892,7 @@ func (p *MDLParser) IndexColumnName() (localctx IIndexColumnNameContext) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(1601) + p.SetState(1672) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -19035,7 +19903,7 @@ func (p *MDLParser) IndexColumnName() (localctx IIndexColumnNameContext) { case MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(1602) + p.SetState(1673) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -19046,7 +19914,7 @@ func (p *MDLParser) IndexColumnName() (localctx IIndexColumnNameContext) { case MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserDEBUG, MDLParserACTION, MDLParserSORT, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserTITLE, MDLParserLABEL, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserEDITABLE, MDLParserVISIBLE, MDLParserSUCCESS, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserERROR, MDLParserRANGE, MDLParserSTATUS, MDLParserVERSION, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserNAVIGATION, MDLParserHOME, MDLParserCHECK, MDLParserTEXT, MDLParserMESSAGE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserFORMAT, MDLParserROLE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserDESCRIPTION, MDLParserOFF: p.EnterOuterAlt(localctx, 3) { - p.SetState(1603) + p.SetState(1674) p.CommonNameKeyword() } @@ -19210,12 +20078,12 @@ func (s *CreateAssociationStatementContext) ExitRule(listener antlr.ParseTreeLis func (p *MDLParser) CreateAssociationStatement() (localctx ICreateAssociationStatementContext) { localctx = NewCreateAssociationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 112, MDLParserRULE_createAssociationStatement) + p.EnterRule(localctx, 116, MDLParserRULE_createAssociationStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1606) + p.SetState(1677) p.Match(MDLParserASSOCIATION) if p.HasError() { // Recognition error - abort rule @@ -19223,11 +20091,11 @@ func (p *MDLParser) CreateAssociationStatement() (localctx ICreateAssociationSta } } { - p.SetState(1607) + p.SetState(1678) p.QualifiedName() } { - p.SetState(1608) + p.SetState(1679) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -19235,11 +20103,11 @@ func (p *MDLParser) CreateAssociationStatement() (localctx ICreateAssociationSta } } { - p.SetState(1609) + p.SetState(1680) p.QualifiedName() } { - p.SetState(1610) + p.SetState(1681) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -19247,10 +20115,10 @@ func (p *MDLParser) CreateAssociationStatement() (localctx ICreateAssociationSta } } { - p.SetState(1611) + p.SetState(1682) p.QualifiedName() } - p.SetState(1613) + p.SetState(1684) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19259,7 +20127,7 @@ func (p *MDLParser) CreateAssociationStatement() (localctx ICreateAssociationSta if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&5633897580724224) != 0) || _la == MDLParserCOMMENT || _la == MDLParserTYPE { { - p.SetState(1612) + p.SetState(1683) p.AssociationOptions() } @@ -19388,11 +20256,11 @@ func (s *AssociationOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AssociationOptions() (localctx IAssociationOptionsContext) { localctx = NewAssociationOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 114, MDLParserRULE_associationOptions) + p.EnterRule(localctx, 118, MDLParserRULE_associationOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1616) + p.SetState(1687) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19401,11 +20269,11 @@ func (p *MDLParser) AssociationOptions() (localctx IAssociationOptionsContext) { for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&5633897580724224) != 0) || _la == MDLParserCOMMENT || _la == MDLParserTYPE { { - p.SetState(1615) + p.SetState(1686) p.AssociationOption() } - p.SetState(1618) + p.SetState(1689) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19570,10 +20438,10 @@ func (s *AssociationOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { localctx = NewAssociationOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 116, MDLParserRULE_associationOption) + p.EnterRule(localctx, 120, MDLParserRULE_associationOption) var _la int - p.SetState(1630) + p.SetState(1701) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19583,7 +20451,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { case MDLParserTYPE: p.EnterOuterAlt(localctx, 1) { - p.SetState(1620) + p.SetState(1691) p.Match(MDLParserTYPE) if p.HasError() { // Recognition error - abort rule @@ -19591,7 +20459,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { } } { - p.SetState(1621) + p.SetState(1692) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserREFERENCE_SET || _la == MDLParserREFERENCE) { @@ -19605,7 +20473,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { case MDLParserOWNER: p.EnterOuterAlt(localctx, 2) { - p.SetState(1622) + p.SetState(1693) p.Match(MDLParserOWNER) if p.HasError() { // Recognition error - abort rule @@ -19613,7 +20481,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { } } { - p.SetState(1623) + p.SetState(1694) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserDEFAULT || _la == MDLParserBOTH) { @@ -19627,7 +20495,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { case MDLParserSTORAGE: p.EnterOuterAlt(localctx, 3) { - p.SetState(1624) + p.SetState(1695) p.Match(MDLParserSTORAGE) if p.HasError() { // Recognition error - abort rule @@ -19635,7 +20503,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { } } { - p.SetState(1625) + p.SetState(1696) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserCOLUMN || _la == MDLParserTABLE) { @@ -19649,7 +20517,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { case MDLParserDELETE_BEHAVIOR: p.EnterOuterAlt(localctx, 4) { - p.SetState(1626) + p.SetState(1697) p.Match(MDLParserDELETE_BEHAVIOR) if p.HasError() { // Recognition error - abort rule @@ -19657,14 +20525,14 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { } } { - p.SetState(1627) + p.SetState(1698) p.DeleteBehavior() } case MDLParserCOMMENT: p.EnterOuterAlt(localctx, 5) { - p.SetState(1628) + p.SetState(1699) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -19672,7 +20540,7 @@ func (p *MDLParser) AssociationOption() (localctx IAssociationOptionContext) { } } { - p.SetState(1629) + p.SetState(1700) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -19790,12 +20658,12 @@ func (s *DeleteBehaviorContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DeleteBehavior() (localctx IDeleteBehaviorContext) { localctx = NewDeleteBehaviorContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 118, MDLParserRULE_deleteBehavior) + p.EnterRule(localctx, 122, MDLParserRULE_deleteBehavior) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1632) + p.SetState(1703) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&27021597764337664) != 0) { @@ -20088,20 +20956,20 @@ func (s *AlterEntityActionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { localctx = NewAlterEntityActionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 120, MDLParserRULE_alterEntityAction) + p.EnterRule(localctx, 124, MDLParserRULE_alterEntityAction) var _la int - p.SetState(1690) + p.SetState(1761) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 110, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 113, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1634) + p.SetState(1705) p.Match(MDLParserADD) if p.HasError() { // Recognition error - abort rule @@ -20109,7 +20977,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1635) + p.SetState(1706) p.Match(MDLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule @@ -20117,14 +20985,14 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1636) + p.SetState(1707) p.AttributeDefinition() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1637) + p.SetState(1708) p.Match(MDLParserADD) if p.HasError() { // Recognition error - abort rule @@ -20132,7 +21000,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1638) + p.SetState(1709) p.Match(MDLParserCOLUMN) if p.HasError() { // Recognition error - abort rule @@ -20140,14 +21008,14 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1639) + p.SetState(1710) p.AttributeDefinition() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1640) + p.SetState(1711) p.Match(MDLParserRENAME) if p.HasError() { // Recognition error - abort rule @@ -20155,7 +21023,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1641) + p.SetState(1712) p.Match(MDLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule @@ -20163,11 +21031,11 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1642) + p.SetState(1713) p.AttributeName() } { - p.SetState(1643) + p.SetState(1714) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -20175,14 +21043,14 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1644) + p.SetState(1715) p.AttributeName() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1646) + p.SetState(1717) p.Match(MDLParserRENAME) if p.HasError() { // Recognition error - abort rule @@ -20190,7 +21058,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1647) + p.SetState(1718) p.Match(MDLParserCOLUMN) if p.HasError() { // Recognition error - abort rule @@ -20198,11 +21066,11 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1648) + p.SetState(1719) p.AttributeName() } { - p.SetState(1649) + p.SetState(1720) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -20210,14 +21078,14 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1650) + p.SetState(1721) p.AttributeName() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1652) + p.SetState(1723) p.Match(MDLParserMODIFY) if p.HasError() { // Recognition error - abort rule @@ -20225,7 +21093,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1653) + p.SetState(1724) p.Match(MDLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule @@ -20233,27 +21101,27 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1654) + p.SetState(1725) p.AttributeName() } { - p.SetState(1655) + p.SetState(1726) p.DataType() } - p.SetState(1659) + p.SetState(1730) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for _la == MDLParserNOT_NULL || ((int64((_la-282)) & ^0x3f) == 0 && ((int64(1)<<(_la-282))&16769) != 0) { + for _la == MDLParserNOT_NULL || ((int64((_la-282)) & ^0x3f) == 0 && ((int64(1)<<(_la-282))&8405377) != 0) { { - p.SetState(1656) + p.SetState(1727) p.AttributeConstraint() } - p.SetState(1661) + p.SetState(1732) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20264,7 +21132,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1662) + p.SetState(1733) p.Match(MDLParserMODIFY) if p.HasError() { // Recognition error - abort rule @@ -20272,7 +21140,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1663) + p.SetState(1734) p.Match(MDLParserCOLUMN) if p.HasError() { // Recognition error - abort rule @@ -20280,27 +21148,27 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1664) + p.SetState(1735) p.AttributeName() } { - p.SetState(1665) + p.SetState(1736) p.DataType() } - p.SetState(1669) + p.SetState(1740) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for _la == MDLParserNOT_NULL || ((int64((_la-282)) & ^0x3f) == 0 && ((int64(1)<<(_la-282))&16769) != 0) { + for _la == MDLParserNOT_NULL || ((int64((_la-282)) & ^0x3f) == 0 && ((int64(1)<<(_la-282))&8405377) != 0) { { - p.SetState(1666) + p.SetState(1737) p.AttributeConstraint() } - p.SetState(1671) + p.SetState(1742) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20311,7 +21179,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(1672) + p.SetState(1743) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -20319,7 +21187,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1673) + p.SetState(1744) p.Match(MDLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule @@ -20327,14 +21195,14 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1674) + p.SetState(1745) p.AttributeName() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(1675) + p.SetState(1746) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -20342,7 +21210,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1676) + p.SetState(1747) p.Match(MDLParserCOLUMN) if p.HasError() { // Recognition error - abort rule @@ -20350,14 +21218,14 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1677) + p.SetState(1748) p.AttributeName() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(1678) + p.SetState(1749) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -20365,7 +21233,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1679) + p.SetState(1750) p.Match(MDLParserDOCUMENTATION) if p.HasError() { // Recognition error - abort rule @@ -20373,7 +21241,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1680) + p.SetState(1751) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -20384,7 +21252,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(1681) + p.SetState(1752) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -20392,7 +21260,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1682) + p.SetState(1753) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -20400,7 +21268,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1683) + p.SetState(1754) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -20411,7 +21279,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(1684) + p.SetState(1755) p.Match(MDLParserADD) if p.HasError() { // Recognition error - abort rule @@ -20419,7 +21287,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1685) + p.SetState(1756) p.Match(MDLParserINDEX) if p.HasError() { // Recognition error - abort rule @@ -20427,14 +21295,14 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1686) + p.SetState(1757) p.IndexDefinition() } case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(1687) + p.SetState(1758) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -20442,7 +21310,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1688) + p.SetState(1759) p.Match(MDLParserINDEX) if p.HasError() { // Recognition error - abort rule @@ -20450,7 +21318,7 @@ func (p *MDLParser) AlterEntityAction() (localctx IAlterEntityActionContext) { } } { - p.SetState(1689) + p.SetState(1760) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -20609,20 +21477,20 @@ func (s *AlterAssociationActionContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionContext) { localctx = NewAlterAssociationActionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 122, MDLParserRULE_alterAssociationAction) + p.EnterRule(localctx, 126, MDLParserRULE_alterAssociationAction) var _la int - p.SetState(1704) + p.SetState(1775) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 111, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 114, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1692) + p.SetState(1763) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -20630,7 +21498,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1693) + p.SetState(1764) p.Match(MDLParserDELETE_BEHAVIOR) if p.HasError() { // Recognition error - abort rule @@ -20638,14 +21506,14 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1694) + p.SetState(1765) p.DeleteBehavior() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1695) + p.SetState(1766) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -20653,7 +21521,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1696) + p.SetState(1767) p.Match(MDLParserOWNER) if p.HasError() { // Recognition error - abort rule @@ -20661,7 +21529,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1697) + p.SetState(1768) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserDEFAULT || _la == MDLParserBOTH) { @@ -20675,7 +21543,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1698) + p.SetState(1769) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -20683,7 +21551,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1699) + p.SetState(1770) p.Match(MDLParserSTORAGE) if p.HasError() { // Recognition error - abort rule @@ -20691,7 +21559,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1700) + p.SetState(1771) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserCOLUMN || _la == MDLParserTABLE) { @@ -20705,7 +21573,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1701) + p.SetState(1772) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -20713,7 +21581,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1702) + p.SetState(1773) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -20721,7 +21589,7 @@ func (p *MDLParser) AlterAssociationAction() (localctx IAlterAssociationActionCo } } { - p.SetState(1703) + p.SetState(1774) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -20868,10 +21736,10 @@ func (s *AlterEnumerationActionContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionContext) { localctx = NewAlterEnumerationActionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 124, MDLParserRULE_alterEnumerationAction) + p.EnterRule(localctx, 128, MDLParserRULE_alterEnumerationAction) var _la int - p.SetState(1724) + p.SetState(1795) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20881,7 +21749,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo case MDLParserADD: p.EnterOuterAlt(localctx, 1) { - p.SetState(1706) + p.SetState(1777) p.Match(MDLParserADD) if p.HasError() { // Recognition error - abort rule @@ -20889,7 +21757,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1707) + p.SetState(1778) p.Match(MDLParserVALUE) if p.HasError() { // Recognition error - abort rule @@ -20897,14 +21765,14 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1708) + p.SetState(1779) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1711) + p.SetState(1782) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20913,7 +21781,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo if _la == MDLParserCAPTION { { - p.SetState(1709) + p.SetState(1780) p.Match(MDLParserCAPTION) if p.HasError() { // Recognition error - abort rule @@ -20921,7 +21789,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1710) + p.SetState(1781) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -20934,7 +21802,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo case MDLParserRENAME: p.EnterOuterAlt(localctx, 2) { - p.SetState(1713) + p.SetState(1784) p.Match(MDLParserRENAME) if p.HasError() { // Recognition error - abort rule @@ -20942,7 +21810,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1714) + p.SetState(1785) p.Match(MDLParserVALUE) if p.HasError() { // Recognition error - abort rule @@ -20950,7 +21818,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1715) + p.SetState(1786) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -20958,7 +21826,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1716) + p.SetState(1787) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -20966,7 +21834,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1717) + p.SetState(1788) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -20977,7 +21845,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo case MDLParserDROP: p.EnterOuterAlt(localctx, 3) { - p.SetState(1718) + p.SetState(1789) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -20985,7 +21853,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1719) + p.SetState(1790) p.Match(MDLParserVALUE) if p.HasError() { // Recognition error - abort rule @@ -20993,7 +21861,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1720) + p.SetState(1791) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -21004,7 +21872,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo case MDLParserSET: p.EnterOuterAlt(localctx, 4) { - p.SetState(1721) + p.SetState(1792) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -21012,7 +21880,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1722) + p.SetState(1793) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -21020,7 +21888,7 @@ func (p *MDLParser) AlterEnumerationAction() (localctx IAlterEnumerationActionCo } } { - p.SetState(1723) + p.SetState(1794) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -21170,10 +22038,10 @@ func (s *AlterNotebookActionContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) { localctx = NewAlterNotebookActionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 126, MDLParserRULE_alterNotebookAction) + p.EnterRule(localctx, 130, MDLParserRULE_alterNotebookAction) var _la int - p.SetState(1739) + p.SetState(1810) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21183,7 +22051,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) case MDLParserADD: p.EnterOuterAlt(localctx, 1) { - p.SetState(1726) + p.SetState(1797) p.Match(MDLParserADD) if p.HasError() { // Recognition error - abort rule @@ -21191,7 +22059,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) } } { - p.SetState(1727) + p.SetState(1798) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -21199,10 +22067,10 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) } } { - p.SetState(1728) + p.SetState(1799) p.QualifiedName() } - p.SetState(1731) + p.SetState(1802) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21211,7 +22079,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) if _la == MDLParserPOSITION { { - p.SetState(1729) + p.SetState(1800) p.Match(MDLParserPOSITION) if p.HasError() { // Recognition error - abort rule @@ -21219,7 +22087,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) } } { - p.SetState(1730) + p.SetState(1801) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -21232,7 +22100,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) case MDLParserDROP: p.EnterOuterAlt(localctx, 2) { - p.SetState(1733) + p.SetState(1804) p.Match(MDLParserDROP) if p.HasError() { // Recognition error - abort rule @@ -21240,7 +22108,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) } } { - p.SetState(1734) + p.SetState(1805) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -21248,14 +22116,14 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) } } { - p.SetState(1735) + p.SetState(1806) p.QualifiedName() } case MDLParserSET: p.EnterOuterAlt(localctx, 3) { - p.SetState(1736) + p.SetState(1807) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule @@ -21263,7 +22131,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) } } { - p.SetState(1737) + p.SetState(1808) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -21271,7 +22139,7 @@ func (p *MDLParser) AlterNotebookAction() (localctx IAlterNotebookActionContext) } } { - p.SetState(1738) + p.SetState(1809) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -21391,12 +22259,12 @@ func (s *CreateModuleStatementContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) CreateModuleStatement() (localctx ICreateModuleStatementContext) { localctx = NewCreateModuleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 128, MDLParserRULE_createModuleStatement) + p.EnterRule(localctx, 132, MDLParserRULE_createModuleStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1741) + p.SetState(1812) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -21404,14 +22272,14 @@ func (p *MDLParser) CreateModuleStatement() (localctx ICreateModuleStatementCont } } { - p.SetState(1742) + p.SetState(1813) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1744) + p.SetState(1815) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21420,7 +22288,7 @@ func (p *MDLParser) CreateModuleStatement() (localctx ICreateModuleStatementCont if _la == MDLParserFOLDER || _la == MDLParserCOMMENT { { - p.SetState(1743) + p.SetState(1814) p.ModuleOptions() } @@ -21549,11 +22417,11 @@ func (s *ModuleOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ModuleOptions() (localctx IModuleOptionsContext) { localctx = NewModuleOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 130, MDLParserRULE_moduleOptions) + p.EnterRule(localctx, 134, MDLParserRULE_moduleOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1747) + p.SetState(1818) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21562,11 +22430,11 @@ func (p *MDLParser) ModuleOptions() (localctx IModuleOptionsContext) { for ok := true; ok; ok = _la == MDLParserFOLDER || _la == MDLParserCOMMENT { { - p.SetState(1746) + p.SetState(1817) p.ModuleOption() } - p.SetState(1749) + p.SetState(1820) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21669,8 +22537,8 @@ func (s *ModuleOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ModuleOption() (localctx IModuleOptionContext) { localctx = NewModuleOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 132, MDLParserRULE_moduleOption) - p.SetState(1755) + p.EnterRule(localctx, 136, MDLParserRULE_moduleOption) + p.SetState(1826) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21680,7 +22548,7 @@ func (p *MDLParser) ModuleOption() (localctx IModuleOptionContext) { case MDLParserCOMMENT: p.EnterOuterAlt(localctx, 1) { - p.SetState(1751) + p.SetState(1822) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -21688,7 +22556,7 @@ func (p *MDLParser) ModuleOption() (localctx IModuleOptionContext) { } } { - p.SetState(1752) + p.SetState(1823) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -21699,7 +22567,7 @@ func (p *MDLParser) ModuleOption() (localctx IModuleOptionContext) { case MDLParserFOLDER: p.EnterOuterAlt(localctx, 2) { - p.SetState(1753) + p.SetState(1824) p.Match(MDLParserFOLDER) if p.HasError() { // Recognition error - abort rule @@ -21707,7 +22575,7 @@ func (p *MDLParser) ModuleOption() (localctx IModuleOptionContext) { } } { - p.SetState(1754) + p.SetState(1825) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -21866,12 +22734,12 @@ func (s *CreateEnumerationStatementContext) ExitRule(listener antlr.ParseTreeLis func (p *MDLParser) CreateEnumerationStatement() (localctx ICreateEnumerationStatementContext) { localctx = NewCreateEnumerationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 134, MDLParserRULE_createEnumerationStatement) + p.EnterRule(localctx, 138, MDLParserRULE_createEnumerationStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1757) + p.SetState(1828) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -21879,11 +22747,11 @@ func (p *MDLParser) CreateEnumerationStatement() (localctx ICreateEnumerationSta } } { - p.SetState(1758) + p.SetState(1829) p.QualifiedName() } { - p.SetState(1759) + p.SetState(1830) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -21891,18 +22759,18 @@ func (p *MDLParser) CreateEnumerationStatement() (localctx ICreateEnumerationSta } } { - p.SetState(1760) + p.SetState(1831) p.EnumerationValueList() } { - p.SetState(1761) + p.SetState(1832) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1763) + p.SetState(1834) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21911,7 +22779,7 @@ func (p *MDLParser) CreateEnumerationStatement() (localctx ICreateEnumerationSta if _la == MDLParserCOMMENT { { - p.SetState(1762) + p.SetState(1833) p.EnumerationOptions() } @@ -22050,15 +22918,15 @@ func (s *EnumerationValueListContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) EnumerationValueList() (localctx IEnumerationValueListContext) { localctx = NewEnumerationValueListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 136, MDLParserRULE_enumerationValueList) + p.EnterRule(localctx, 140, MDLParserRULE_enumerationValueList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1765) + p.SetState(1836) p.EnumerationValue() } - p.SetState(1770) + p.SetState(1841) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22067,7 +22935,7 @@ func (p *MDLParser) EnumerationValueList() (localctx IEnumerationValueListContex for _la == MDLParserCOMMA { { - p.SetState(1766) + p.SetState(1837) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -22075,11 +22943,11 @@ func (p *MDLParser) EnumerationValueList() (localctx IEnumerationValueListContex } } { - p.SetState(1767) + p.SetState(1838) p.EnumerationValue() } - p.SetState(1772) + p.SetState(1843) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22211,11 +23079,11 @@ func (s *EnumerationValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EnumerationValue() (localctx IEnumerationValueContext) { localctx = NewEnumerationValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 138, MDLParserRULE_enumerationValue) + p.EnterRule(localctx, 142, MDLParserRULE_enumerationValue) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1774) + p.SetState(1845) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22224,16 +23092,16 @@ func (p *MDLParser) EnumerationValue() (localctx IEnumerationValueContext) { if _la == MDLParserDOC_COMMENT { { - p.SetState(1773) + p.SetState(1844) p.DocComment() } } { - p.SetState(1776) + p.SetState(1847) p.EnumValueName() } - p.SetState(1781) + p.SetState(1852) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22241,7 +23109,7 @@ func (p *MDLParser) EnumerationValue() (localctx IEnumerationValueContext) { _la = p.GetTokenStream().LA(1) if _la == MDLParserCAPTION || _la == MDLParserSTRING_LITERAL { - p.SetState(1778) + p.SetState(1849) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22250,7 +23118,7 @@ func (p *MDLParser) EnumerationValue() (localctx IEnumerationValueContext) { if _la == MDLParserCAPTION { { - p.SetState(1777) + p.SetState(1848) p.Match(MDLParserCAPTION) if p.HasError() { // Recognition error - abort rule @@ -22260,7 +23128,7 @@ func (p *MDLParser) EnumerationValue() (localctx IEnumerationValueContext) { } { - p.SetState(1780) + p.SetState(1851) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -22437,8 +23305,8 @@ func (s *EnumValueNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { localctx = NewEnumValueNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 140, MDLParserRULE_enumValueName) - p.SetState(1798) + p.EnterRule(localctx, 144, MDLParserRULE_enumValueName) + p.SetState(1869) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22448,7 +23316,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(1783) + p.SetState(1854) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -22459,7 +23327,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(1784) + p.SetState(1855) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -22470,14 +23338,14 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserDEBUG, MDLParserACTION, MDLParserSORT, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserTITLE, MDLParserLABEL, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserEDITABLE, MDLParserVISIBLE, MDLParserSUCCESS, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserERROR, MDLParserRANGE, MDLParserSTATUS, MDLParserVERSION, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserNAVIGATION, MDLParserHOME, MDLParserCHECK, MDLParserTEXT, MDLParserMESSAGE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserFORMAT, MDLParserROLE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserDESCRIPTION, MDLParserOFF: p.EnterOuterAlt(localctx, 3) { - p.SetState(1785) + p.SetState(1856) p.CommonNameKeyword() } case MDLParserSERVICE: p.EnterOuterAlt(localctx, 4) { - p.SetState(1786) + p.SetState(1857) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -22488,7 +23356,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserSERVICES: p.EnterOuterAlt(localctx, 5) { - p.SetState(1787) + p.SetState(1858) p.Match(MDLParserSERVICES) if p.HasError() { // Recognition error - abort rule @@ -22499,7 +23367,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserGUEST: p.EnterOuterAlt(localctx, 6) { - p.SetState(1788) + p.SetState(1859) p.Match(MDLParserGUEST) if p.HasError() { // Recognition error - abort rule @@ -22510,7 +23378,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserSESSION: p.EnterOuterAlt(localctx, 7) { - p.SetState(1789) + p.SetState(1860) p.Match(MDLParserSESSION) if p.HasError() { // Recognition error - abort rule @@ -22521,7 +23389,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserBASIC: p.EnterOuterAlt(localctx, 8) { - p.SetState(1790) + p.SetState(1861) p.Match(MDLParserBASIC) if p.HasError() { // Recognition error - abort rule @@ -22532,7 +23400,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserCLIENT: p.EnterOuterAlt(localctx, 9) { - p.SetState(1791) + p.SetState(1862) p.Match(MDLParserCLIENT) if p.HasError() { // Recognition error - abort rule @@ -22543,7 +23411,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserCLIENTS: p.EnterOuterAlt(localctx, 10) { - p.SetState(1792) + p.SetState(1863) p.Match(MDLParserCLIENTS) if p.HasError() { // Recognition error - abort rule @@ -22554,7 +23422,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserPUBLISH: p.EnterOuterAlt(localctx, 11) { - p.SetState(1793) + p.SetState(1864) p.Match(MDLParserPUBLISH) if p.HasError() { // Recognition error - abort rule @@ -22565,7 +23433,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserEXPOSE: p.EnterOuterAlt(localctx, 12) { - p.SetState(1794) + p.SetState(1865) p.Match(MDLParserEXPOSE) if p.HasError() { // Recognition error - abort rule @@ -22576,7 +23444,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserEXTERNAL: p.EnterOuterAlt(localctx, 13) { - p.SetState(1795) + p.SetState(1866) p.Match(MDLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule @@ -22587,7 +23455,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserPAGING: p.EnterOuterAlt(localctx, 14) { - p.SetState(1796) + p.SetState(1867) p.Match(MDLParserPAGING) if p.HasError() { // Recognition error - abort rule @@ -22598,7 +23466,7 @@ func (p *MDLParser) EnumValueName() (localctx IEnumValueNameContext) { case MDLParserHEADERS: p.EnterOuterAlt(localctx, 15) { - p.SetState(1797) + p.SetState(1868) p.Match(MDLParserHEADERS) if p.HasError() { // Recognition error - abort rule @@ -22734,11 +23602,11 @@ func (s *EnumerationOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EnumerationOptions() (localctx IEnumerationOptionsContext) { localctx = NewEnumerationOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 142, MDLParserRULE_enumerationOptions) + p.EnterRule(localctx, 146, MDLParserRULE_enumerationOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1801) + p.SetState(1872) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22747,11 +23615,11 @@ func (p *MDLParser) EnumerationOptions() (localctx IEnumerationOptionsContext) { for ok := true; ok; ok = _la == MDLParserCOMMENT { { - p.SetState(1800) + p.SetState(1871) p.EnumerationOption() } - p.SetState(1803) + p.SetState(1874) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22849,10 +23717,10 @@ func (s *EnumerationOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) EnumerationOption() (localctx IEnumerationOptionContext) { localctx = NewEnumerationOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 144, MDLParserRULE_enumerationOption) + p.EnterRule(localctx, 148, MDLParserRULE_enumerationOption) p.EnterOuterAlt(localctx, 1) { - p.SetState(1805) + p.SetState(1876) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -22860,7 +23728,7 @@ func (p *MDLParser) EnumerationOption() (localctx IEnumerationOptionContext) { } } { - p.SetState(1806) + p.SetState(1877) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23023,10 +23891,10 @@ func (s *CreateValidationRuleStatementContext) ExitRule(listener antlr.ParseTree func (p *MDLParser) CreateValidationRuleStatement() (localctx ICreateValidationRuleStatementContext) { localctx = NewCreateValidationRuleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 146, MDLParserRULE_createValidationRuleStatement) + p.EnterRule(localctx, 150, MDLParserRULE_createValidationRuleStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1808) + p.SetState(1879) p.Match(MDLParserVALIDATION) if p.HasError() { // Recognition error - abort rule @@ -23034,7 +23902,7 @@ func (p *MDLParser) CreateValidationRuleStatement() (localctx ICreateValidationR } } { - p.SetState(1809) + p.SetState(1880) p.Match(MDLParserRULE) if p.HasError() { // Recognition error - abort rule @@ -23042,11 +23910,11 @@ func (p *MDLParser) CreateValidationRuleStatement() (localctx ICreateValidationR } } { - p.SetState(1810) + p.SetState(1881) p.QualifiedName() } { - p.SetState(1811) + p.SetState(1882) p.Match(MDLParserFOR) if p.HasError() { // Recognition error - abort rule @@ -23054,11 +23922,11 @@ func (p *MDLParser) CreateValidationRuleStatement() (localctx ICreateValidationR } } { - p.SetState(1812) + p.SetState(1883) p.QualifiedName() } { - p.SetState(1813) + p.SetState(1884) p.ValidationRuleBody() } @@ -23250,8 +24118,8 @@ func (s *ValidationRuleBodyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { localctx = NewValidationRuleBodyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 148, MDLParserRULE_validationRuleBody) - p.SetState(1842) + p.EnterRule(localctx, 152, MDLParserRULE_validationRuleBody) + p.SetState(1913) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23261,7 +24129,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { case MDLParserEXPRESSION: p.EnterOuterAlt(localctx, 1) { - p.SetState(1815) + p.SetState(1886) p.Match(MDLParserEXPRESSION) if p.HasError() { // Recognition error - abort rule @@ -23269,11 +24137,11 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1816) + p.SetState(1887) p.Expression() } { - p.SetState(1817) + p.SetState(1888) p.Match(MDLParserFEEDBACK) if p.HasError() { // Recognition error - abort rule @@ -23281,7 +24149,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1818) + p.SetState(1889) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23292,7 +24160,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { case MDLParserREQUIRED: p.EnterOuterAlt(localctx, 2) { - p.SetState(1820) + p.SetState(1891) p.Match(MDLParserREQUIRED) if p.HasError() { // Recognition error - abort rule @@ -23300,11 +24168,11 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1821) + p.SetState(1892) p.AttributeReference() } { - p.SetState(1822) + p.SetState(1893) p.Match(MDLParserFEEDBACK) if p.HasError() { // Recognition error - abort rule @@ -23312,7 +24180,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1823) + p.SetState(1894) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23323,7 +24191,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { case MDLParserUNIQUE: p.EnterOuterAlt(localctx, 3) { - p.SetState(1825) + p.SetState(1896) p.Match(MDLParserUNIQUE) if p.HasError() { // Recognition error - abort rule @@ -23331,11 +24199,11 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1826) + p.SetState(1897) p.AttributeReferenceList() } { - p.SetState(1827) + p.SetState(1898) p.Match(MDLParserFEEDBACK) if p.HasError() { // Recognition error - abort rule @@ -23343,7 +24211,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1828) + p.SetState(1899) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23354,7 +24222,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { case MDLParserRANGE: p.EnterOuterAlt(localctx, 4) { - p.SetState(1830) + p.SetState(1901) p.Match(MDLParserRANGE) if p.HasError() { // Recognition error - abort rule @@ -23362,15 +24230,15 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1831) + p.SetState(1902) p.AttributeReference() } { - p.SetState(1832) + p.SetState(1903) p.RangeConstraint() } { - p.SetState(1833) + p.SetState(1904) p.Match(MDLParserFEEDBACK) if p.HasError() { // Recognition error - abort rule @@ -23378,7 +24246,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1834) + p.SetState(1905) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23389,7 +24257,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { case MDLParserREGEX: p.EnterOuterAlt(localctx, 5) { - p.SetState(1836) + p.SetState(1907) p.Match(MDLParserREGEX) if p.HasError() { // Recognition error - abort rule @@ -23397,11 +24265,11 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1837) + p.SetState(1908) p.AttributeReference() } { - p.SetState(1838) + p.SetState(1909) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23409,7 +24277,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1839) + p.SetState(1910) p.Match(MDLParserFEEDBACK) if p.HasError() { // Recognition error - abort rule @@ -23417,7 +24285,7 @@ func (p *MDLParser) ValidationRuleBody() (localctx IValidationRuleBodyContext) { } } { - p.SetState(1840) + p.SetState(1911) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23583,8 +24451,8 @@ func (s *RangeConstraintContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { localctx = NewRangeConstraintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 150, MDLParserRULE_rangeConstraint) - p.SetState(1857) + p.EnterRule(localctx, 154, MDLParserRULE_rangeConstraint) + p.SetState(1928) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23594,7 +24462,7 @@ func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { case MDLParserBETWEEN: p.EnterOuterAlt(localctx, 1) { - p.SetState(1844) + p.SetState(1915) p.Match(MDLParserBETWEEN) if p.HasError() { // Recognition error - abort rule @@ -23602,11 +24470,11 @@ func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { } } { - p.SetState(1845) + p.SetState(1916) p.Literal() } { - p.SetState(1846) + p.SetState(1917) p.Match(MDLParserAND) if p.HasError() { // Recognition error - abort rule @@ -23614,14 +24482,14 @@ func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { } } { - p.SetState(1847) + p.SetState(1918) p.Literal() } case MDLParserLESS_THAN: p.EnterOuterAlt(localctx, 2) { - p.SetState(1849) + p.SetState(1920) p.Match(MDLParserLESS_THAN) if p.HasError() { // Recognition error - abort rule @@ -23629,14 +24497,14 @@ func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { } } { - p.SetState(1850) + p.SetState(1921) p.Literal() } case MDLParserLESS_THAN_OR_EQUAL: p.EnterOuterAlt(localctx, 3) { - p.SetState(1851) + p.SetState(1922) p.Match(MDLParserLESS_THAN_OR_EQUAL) if p.HasError() { // Recognition error - abort rule @@ -23644,14 +24512,14 @@ func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { } } { - p.SetState(1852) + p.SetState(1923) p.Literal() } case MDLParserGREATER_THAN: p.EnterOuterAlt(localctx, 4) { - p.SetState(1853) + p.SetState(1924) p.Match(MDLParserGREATER_THAN) if p.HasError() { // Recognition error - abort rule @@ -23659,14 +24527,14 @@ func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { } } { - p.SetState(1854) + p.SetState(1925) p.Literal() } case MDLParserGREATER_THAN_OR_EQUAL: p.EnterOuterAlt(localctx, 5) { - p.SetState(1855) + p.SetState(1926) p.Match(MDLParserGREATER_THAN_OR_EQUAL) if p.HasError() { // Recognition error - abort rule @@ -23674,7 +24542,7 @@ func (p *MDLParser) RangeConstraint() (localctx IRangeConstraintContext) { } } { - p.SetState(1856) + p.SetState(1927) p.Literal() } @@ -23783,19 +24651,19 @@ func (s *AttributeReferenceContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AttributeReference() (localctx IAttributeReferenceContext) { localctx = NewAttributeReferenceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 152, MDLParserRULE_attributeReference) + p.EnterRule(localctx, 156, MDLParserRULE_attributeReference) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1859) + p.SetState(1930) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1864) + p.SetState(1935) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23804,7 +24672,7 @@ func (p *MDLParser) AttributeReference() (localctx IAttributeReferenceContext) { for _la == MDLParserSLASH { { - p.SetState(1860) + p.SetState(1931) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule @@ -23812,7 +24680,7 @@ func (p *MDLParser) AttributeReference() (localctx IAttributeReferenceContext) { } } { - p.SetState(1861) + p.SetState(1932) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -23820,7 +24688,7 @@ func (p *MDLParser) AttributeReference() (localctx IAttributeReferenceContext) { } } - p.SetState(1866) + p.SetState(1937) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23961,15 +24829,15 @@ func (s *AttributeReferenceListContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) AttributeReferenceList() (localctx IAttributeReferenceListContext) { localctx = NewAttributeReferenceListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 154, MDLParserRULE_attributeReferenceList) + p.EnterRule(localctx, 158, MDLParserRULE_attributeReferenceList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1867) + p.SetState(1938) p.AttributeReference() } - p.SetState(1872) + p.SetState(1943) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23978,7 +24846,7 @@ func (p *MDLParser) AttributeReferenceList() (localctx IAttributeReferenceListCo for _la == MDLParserCOMMA { { - p.SetState(1868) + p.SetState(1939) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -23986,11 +24854,11 @@ func (p *MDLParser) AttributeReferenceList() (localctx IAttributeReferenceListCo } } { - p.SetState(1869) + p.SetState(1940) p.AttributeReference() } - p.SetState(1874) + p.SetState(1945) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24198,12 +25066,12 @@ func (s *CreateMicroflowStatementContext) ExitRule(listener antlr.ParseTreeListe func (p *MDLParser) CreateMicroflowStatement() (localctx ICreateMicroflowStatementContext) { localctx = NewCreateMicroflowStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 156, MDLParserRULE_createMicroflowStatement) + p.EnterRule(localctx, 160, MDLParserRULE_createMicroflowStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1875) + p.SetState(1946) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -24211,40 +25079,40 @@ func (p *MDLParser) CreateMicroflowStatement() (localctx ICreateMicroflowStateme } } { - p.SetState(1876) + p.SetState(1947) p.QualifiedName() } { - p.SetState(1877) + p.SetState(1948) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1879) + p.SetState(1950) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-481)) & ^0x3f) == 0 && ((int64(1)<<(_la-481))&11) != 0) { + if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&11) != 0) { { - p.SetState(1878) + p.SetState(1949) p.MicroflowParameterList() } } { - p.SetState(1881) + p.SetState(1952) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1883) + p.SetState(1954) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24253,12 +25121,12 @@ func (p *MDLParser) CreateMicroflowStatement() (localctx ICreateMicroflowStateme if _la == MDLParserRETURNS { { - p.SetState(1882) + p.SetState(1953) p.MicroflowReturnType() } } - p.SetState(1886) + p.SetState(1957) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24267,13 +25135,13 @@ func (p *MDLParser) CreateMicroflowStatement() (localctx ICreateMicroflowStateme if _la == MDLParserFOLDER || _la == MDLParserCOMMENT { { - p.SetState(1885) + p.SetState(1956) p.MicroflowOptions() } } { - p.SetState(1888) + p.SetState(1959) p.Match(MDLParserBEGIN) if p.HasError() { // Recognition error - abort rule @@ -24281,23 +25149,23 @@ func (p *MDLParser) CreateMicroflowStatement() (localctx ICreateMicroflowStateme } } { - p.SetState(1889) + p.SetState(1960) p.MicroflowBody() } { - p.SetState(1890) + p.SetState(1961) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1892) + p.SetState(1963) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 133, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 136, p.GetParserRuleContext()) == 1 { { - p.SetState(1891) + p.SetState(1962) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -24308,12 +25176,12 @@ func (p *MDLParser) CreateMicroflowStatement() (localctx ICreateMicroflowStateme } else if p.HasError() { // JIM goto errorExit } - p.SetState(1895) + p.SetState(1966) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 134, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 137, p.GetParserRuleContext()) == 1 { { - p.SetState(1894) + p.SetState(1965) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule @@ -24508,12 +25376,12 @@ func (s *CreateJavaActionStatementContext) ExitRule(listener antlr.ParseTreeList func (p *MDLParser) CreateJavaActionStatement() (localctx ICreateJavaActionStatementContext) { localctx = NewCreateJavaActionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 158, MDLParserRULE_createJavaActionStatement) + p.EnterRule(localctx, 162, MDLParserRULE_createJavaActionStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1897) + p.SetState(1968) p.Match(MDLParserJAVA) if p.HasError() { // Recognition error - abort rule @@ -24521,7 +25389,7 @@ func (p *MDLParser) CreateJavaActionStatement() (localctx ICreateJavaActionState } } { - p.SetState(1898) + p.SetState(1969) p.Match(MDLParserACTION) if p.HasError() { // Recognition error - abort rule @@ -24529,40 +25397,40 @@ func (p *MDLParser) CreateJavaActionStatement() (localctx ICreateJavaActionState } } { - p.SetState(1899) + p.SetState(1970) p.QualifiedName() } { - p.SetState(1900) + p.SetState(1971) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1902) + p.SetState(1973) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || _la == MDLParserIDENTIFIER || _la == MDLParserQUOTED_IDENTIFIER { + if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || _la == MDLParserIDENTIFIER || _la == MDLParserQUOTED_IDENTIFIER { { - p.SetState(1901) + p.SetState(1972) p.JavaActionParameterList() } } { - p.SetState(1904) + p.SetState(1975) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1906) + p.SetState(1977) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24571,12 +25439,12 @@ func (p *MDLParser) CreateJavaActionStatement() (localctx ICreateJavaActionState if _la == MDLParserRETURNS { { - p.SetState(1905) + p.SetState(1976) p.JavaActionReturnType() } } - p.SetState(1909) + p.SetState(1980) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24585,13 +25453,13 @@ func (p *MDLParser) CreateJavaActionStatement() (localctx ICreateJavaActionState if _la == MDLParserEXPOSED { { - p.SetState(1908) + p.SetState(1979) p.JavaActionExposedClause() } } { - p.SetState(1911) + p.SetState(1982) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -24599,19 +25467,19 @@ func (p *MDLParser) CreateJavaActionStatement() (localctx ICreateJavaActionState } } { - p.SetState(1912) + p.SetState(1983) p.Match(MDLParserDOLLAR_STRING) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1914) + p.SetState(1985) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 138, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 141, p.GetParserRuleContext()) == 1 { { - p.SetState(1913) + p.SetState(1984) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -24756,15 +25624,15 @@ func (s *JavaActionParameterListContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) JavaActionParameterList() (localctx IJavaActionParameterListContext) { localctx = NewJavaActionParameterListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 160, MDLParserRULE_javaActionParameterList) + p.EnterRule(localctx, 164, MDLParserRULE_javaActionParameterList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1916) + p.SetState(1987) p.JavaActionParameter() } - p.SetState(1921) + p.SetState(1992) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24773,7 +25641,7 @@ func (p *MDLParser) JavaActionParameterList() (localctx IJavaActionParameterList for _la == MDLParserCOMMA { { - p.SetState(1917) + p.SetState(1988) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -24781,11 +25649,11 @@ func (p *MDLParser) JavaActionParameterList() (localctx IJavaActionParameterList } } { - p.SetState(1918) + p.SetState(1989) p.JavaActionParameter() } - p.SetState(1923) + p.SetState(1994) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24917,16 +25785,16 @@ func (s *JavaActionParameterContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) JavaActionParameter() (localctx IJavaActionParameterContext) { localctx = NewJavaActionParameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 162, MDLParserRULE_javaActionParameter) + p.EnterRule(localctx, 166, MDLParserRULE_javaActionParameter) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1924) + p.SetState(1995) p.ParameterName() } { - p.SetState(1925) + p.SetState(1996) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -24934,10 +25802,10 @@ func (p *MDLParser) JavaActionParameter() (localctx IJavaActionParameterContext) } } { - p.SetState(1926) + p.SetState(1997) p.DataType() } - p.SetState(1928) + p.SetState(1999) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24946,7 +25814,7 @@ func (p *MDLParser) JavaActionParameter() (localctx IJavaActionParameterContext) if _la == MDLParserNOT_NULL { { - p.SetState(1927) + p.SetState(1998) p.Match(MDLParserNOT_NULL) if p.HasError() { // Recognition error - abort rule @@ -25058,10 +25926,10 @@ func (s *JavaActionReturnTypeContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) JavaActionReturnType() (localctx IJavaActionReturnTypeContext) { localctx = NewJavaActionReturnTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 164, MDLParserRULE_javaActionReturnType) + p.EnterRule(localctx, 168, MDLParserRULE_javaActionReturnType) p.EnterOuterAlt(localctx, 1) { - p.SetState(1930) + p.SetState(2001) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -25069,7 +25937,7 @@ func (p *MDLParser) JavaActionReturnType() (localctx IJavaActionReturnTypeContex } } { - p.SetState(1931) + p.SetState(2002) p.DataType() } @@ -25178,10 +26046,10 @@ func (s *JavaActionExposedClauseContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) JavaActionExposedClause() (localctx IJavaActionExposedClauseContext) { localctx = NewJavaActionExposedClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 166, MDLParserRULE_javaActionExposedClause) + p.EnterRule(localctx, 170, MDLParserRULE_javaActionExposedClause) p.EnterOuterAlt(localctx, 1) { - p.SetState(1933) + p.SetState(2004) p.Match(MDLParserEXPOSED) if p.HasError() { // Recognition error - abort rule @@ -25189,7 +26057,7 @@ func (p *MDLParser) JavaActionExposedClause() (localctx IJavaActionExposedClause } } { - p.SetState(1934) + p.SetState(2005) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -25197,7 +26065,7 @@ func (p *MDLParser) JavaActionExposedClause() (localctx IJavaActionExposedClause } } { - p.SetState(1935) + p.SetState(2006) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -25205,7 +26073,7 @@ func (p *MDLParser) JavaActionExposedClause() (localctx IJavaActionExposedClause } } { - p.SetState(1936) + p.SetState(2007) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule @@ -25213,7 +26081,7 @@ func (p *MDLParser) JavaActionExposedClause() (localctx IJavaActionExposedClause } } { - p.SetState(1937) + p.SetState(2008) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -25354,15 +26222,15 @@ func (s *MicroflowParameterListContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) MicroflowParameterList() (localctx IMicroflowParameterListContext) { localctx = NewMicroflowParameterListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 168, MDLParserRULE_microflowParameterList) + p.EnterRule(localctx, 172, MDLParserRULE_microflowParameterList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1939) + p.SetState(2010) p.MicroflowParameter() } - p.SetState(1944) + p.SetState(2015) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25371,7 +26239,7 @@ func (p *MDLParser) MicroflowParameterList() (localctx IMicroflowParameterListCo for _la == MDLParserCOMMA { { - p.SetState(1940) + p.SetState(2011) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -25379,11 +26247,11 @@ func (p *MDLParser) MicroflowParameterList() (localctx IMicroflowParameterListCo } } { - p.SetState(1941) + p.SetState(2012) p.MicroflowParameter() } - p.SetState(1946) + p.SetState(2017) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25515,9 +26383,9 @@ func (s *MicroflowParameterContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MicroflowParameter() (localctx IMicroflowParameterContext) { localctx = NewMicroflowParameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 170, MDLParserRULE_microflowParameter) + p.EnterRule(localctx, 174, MDLParserRULE_microflowParameter) p.EnterOuterAlt(localctx, 1) - p.SetState(1949) + p.SetState(2020) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25526,13 +26394,13 @@ func (p *MDLParser) MicroflowParameter() (localctx IMicroflowParameterContext) { switch p.GetTokenStream().LA(1) { case MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserDEBUG, MDLParserACTION, MDLParserSORT, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserTITLE, MDLParserLABEL, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserEDITABLE, MDLParserVISIBLE, MDLParserSUCCESS, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserERROR, MDLParserRANGE, MDLParserSTATUS, MDLParserVERSION, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserNAVIGATION, MDLParserHOME, MDLParserCHECK, MDLParserTEXT, MDLParserMESSAGE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserFORMAT, MDLParserROLE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserDESCRIPTION, MDLParserOFF, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: { - p.SetState(1947) + p.SetState(2018) p.ParameterName() } case MDLParserVARIABLE: { - p.SetState(1948) + p.SetState(2019) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -25545,7 +26413,7 @@ func (p *MDLParser) MicroflowParameter() (localctx IMicroflowParameterContext) { goto errorExit } { - p.SetState(1951) + p.SetState(2022) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -25553,7 +26421,7 @@ func (p *MDLParser) MicroflowParameter() (localctx IMicroflowParameterContext) { } } { - p.SetState(1952) + p.SetState(2023) p.DataType() } @@ -25664,8 +26532,8 @@ func (s *ParameterNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ParameterName() (localctx IParameterNameContext) { localctx = NewParameterNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 172, MDLParserRULE_parameterName) - p.SetState(1957) + p.EnterRule(localctx, 176, MDLParserRULE_parameterName) + p.SetState(2028) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25675,7 +26543,7 @@ func (p *MDLParser) ParameterName() (localctx IParameterNameContext) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(1954) + p.SetState(2025) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -25686,7 +26554,7 @@ func (p *MDLParser) ParameterName() (localctx IParameterNameContext) { case MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(1955) + p.SetState(2026) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -25697,7 +26565,7 @@ func (p *MDLParser) ParameterName() (localctx IParameterNameContext) { case MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserDEBUG, MDLParserACTION, MDLParserSORT, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserTITLE, MDLParserLABEL, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserEDITABLE, MDLParserVISIBLE, MDLParserSUCCESS, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserERROR, MDLParserRANGE, MDLParserSTATUS, MDLParserVERSION, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserNAVIGATION, MDLParserHOME, MDLParserCHECK, MDLParserTEXT, MDLParserMESSAGE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserFORMAT, MDLParserROLE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserDESCRIPTION, MDLParserOFF: p.EnterOuterAlt(localctx, 3) { - p.SetState(1956) + p.SetState(2027) p.CommonNameKeyword() } @@ -25818,12 +26686,12 @@ func (s *MicroflowReturnTypeContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) MicroflowReturnType() (localctx IMicroflowReturnTypeContext) { localctx = NewMicroflowReturnTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 174, MDLParserRULE_microflowReturnType) + p.EnterRule(localctx, 178, MDLParserRULE_microflowReturnType) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(1959) + p.SetState(2030) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -25831,10 +26699,10 @@ func (p *MDLParser) MicroflowReturnType() (localctx IMicroflowReturnTypeContext) } } { - p.SetState(1960) + p.SetState(2031) p.DataType() } - p.SetState(1963) + p.SetState(2034) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25843,7 +26711,7 @@ func (p *MDLParser) MicroflowReturnType() (localctx IMicroflowReturnTypeContext) if _la == MDLParserAS { { - p.SetState(1961) + p.SetState(2032) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -25851,7 +26719,7 @@ func (p *MDLParser) MicroflowReturnType() (localctx IMicroflowReturnTypeContext) } } { - p.SetState(1962) + p.SetState(2033) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -25984,11 +26852,11 @@ func (s *MicroflowOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MicroflowOptions() (localctx IMicroflowOptionsContext) { localctx = NewMicroflowOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 176, MDLParserRULE_microflowOptions) + p.EnterRule(localctx, 180, MDLParserRULE_microflowOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1966) + p.SetState(2037) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25997,11 +26865,11 @@ func (p *MDLParser) MicroflowOptions() (localctx IMicroflowOptionsContext) { for ok := true; ok; ok = _la == MDLParserFOLDER || _la == MDLParserCOMMENT { { - p.SetState(1965) + p.SetState(2036) p.MicroflowOption() } - p.SetState(1968) + p.SetState(2039) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26104,8 +26972,8 @@ func (s *MicroflowOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MicroflowOption() (localctx IMicroflowOptionContext) { localctx = NewMicroflowOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 178, MDLParserRULE_microflowOption) - p.SetState(1974) + p.EnterRule(localctx, 182, MDLParserRULE_microflowOption) + p.SetState(2045) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26115,7 +26983,7 @@ func (p *MDLParser) MicroflowOption() (localctx IMicroflowOptionContext) { case MDLParserFOLDER: p.EnterOuterAlt(localctx, 1) { - p.SetState(1970) + p.SetState(2041) p.Match(MDLParserFOLDER) if p.HasError() { // Recognition error - abort rule @@ -26123,7 +26991,7 @@ func (p *MDLParser) MicroflowOption() (localctx IMicroflowOptionContext) { } } { - p.SetState(1971) + p.SetState(2042) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -26134,7 +27002,7 @@ func (p *MDLParser) MicroflowOption() (localctx IMicroflowOptionContext) { case MDLParserCOMMENT: p.EnterOuterAlt(localctx, 2) { - p.SetState(1972) + p.SetState(2043) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -26142,7 +27010,7 @@ func (p *MDLParser) MicroflowOption() (localctx IMicroflowOptionContext) { } } { - p.SetState(1973) + p.SetState(2044) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -26278,24 +27146,24 @@ func (s *MicroflowBodyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MicroflowBody() (localctx IMicroflowBodyContext) { localctx = NewMicroflowBodyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 180, MDLParserRULE_microflowBody) + p.EnterRule(localctx, 184, MDLParserRULE_microflowBody) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1979) + p.SetState(2050) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for ((int64((_la-17)) & ^0x3f) == 0 && ((int64(1)<<(_la-17))&140739098968065) != 0) || ((int64((_la-96)) & ^0x3f) == 0 && ((int64(1)<<(_la-96))&34360916479) != 0) || ((int64((_la-293)) & ^0x3f) == 0 && ((int64(1)<<(_la-293))&4129) != 0) || _la == MDLParserEXECUTE || _la == MDLParserAT || _la == MDLParserVARIABLE { + for ((int64((_la-17)) & ^0x3f) == 0 && ((int64(1)<<(_la-17))&140739098968065) != 0) || ((int64((_la-96)) & ^0x3f) == 0 && ((int64(1)<<(_la-96))&34360916479) != 0) || ((int64((_la-293)) & ^0x3f) == 0 && ((int64(1)<<(_la-293))&8225) != 0) || _la == MDLParserEXECUTE || _la == MDLParserAT || _la == MDLParserVARIABLE { { - p.SetState(1976) + p.SetState(2047) p.MicroflowStatement() } - p.SetState(1981) + p.SetState(2052) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26975,19 +27843,19 @@ func (s *MicroflowStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { localctx = NewMicroflowStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 182, MDLParserRULE_microflowStatement) + p.EnterRule(localctx, 186, MDLParserRULE_microflowStatement) var _la int - p.SetState(2302) + p.SetState(2373) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 212, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 215, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) - p.SetState(1985) + p.SetState(2056) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26996,11 +27864,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(1982) + p.SetState(2053) p.Annotation() } - p.SetState(1987) + p.SetState(2058) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27008,10 +27876,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1988) + p.SetState(2059) p.DeclareStatement() } - p.SetState(1990) + p.SetState(2061) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27020,7 +27888,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(1989) + p.SetState(2060) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27032,7 +27900,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 2: p.EnterOuterAlt(localctx, 2) - p.SetState(1995) + p.SetState(2066) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27041,11 +27909,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(1992) + p.SetState(2063) p.Annotation() } - p.SetState(1997) + p.SetState(2068) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27053,10 +27921,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1998) + p.SetState(2069) p.SetStatement() } - p.SetState(2000) + p.SetState(2071) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27065,7 +27933,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(1999) + p.SetState(2070) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27077,7 +27945,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 3: p.EnterOuterAlt(localctx, 3) - p.SetState(2005) + p.SetState(2076) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27086,11 +27954,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2002) + p.SetState(2073) p.Annotation() } - p.SetState(2007) + p.SetState(2078) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27098,10 +27966,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2008) + p.SetState(2079) p.CreateListStatement() } - p.SetState(2010) + p.SetState(2081) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27110,7 +27978,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2009) + p.SetState(2080) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27122,7 +27990,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 4: p.EnterOuterAlt(localctx, 4) - p.SetState(2015) + p.SetState(2086) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27131,11 +27999,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2012) + p.SetState(2083) p.Annotation() } - p.SetState(2017) + p.SetState(2088) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27143,10 +28011,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2018) + p.SetState(2089) p.CreateObjectStatement() } - p.SetState(2020) + p.SetState(2091) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27155,7 +28023,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2019) + p.SetState(2090) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27167,7 +28035,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 5: p.EnterOuterAlt(localctx, 5) - p.SetState(2025) + p.SetState(2096) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27176,11 +28044,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2022) + p.SetState(2093) p.Annotation() } - p.SetState(2027) + p.SetState(2098) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27188,10 +28056,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2028) + p.SetState(2099) p.ChangeObjectStatement() } - p.SetState(2030) + p.SetState(2101) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27200,7 +28068,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2029) + p.SetState(2100) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27212,7 +28080,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 6: p.EnterOuterAlt(localctx, 6) - p.SetState(2035) + p.SetState(2106) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27221,11 +28089,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2032) + p.SetState(2103) p.Annotation() } - p.SetState(2037) + p.SetState(2108) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27233,10 +28101,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2038) + p.SetState(2109) p.CommitStatement() } - p.SetState(2040) + p.SetState(2111) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27245,7 +28113,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2039) + p.SetState(2110) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27257,7 +28125,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 7: p.EnterOuterAlt(localctx, 7) - p.SetState(2045) + p.SetState(2116) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27266,11 +28134,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2042) + p.SetState(2113) p.Annotation() } - p.SetState(2047) + p.SetState(2118) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27278,10 +28146,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2048) + p.SetState(2119) p.DeleteObjectStatement() } - p.SetState(2050) + p.SetState(2121) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27290,7 +28158,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2049) + p.SetState(2120) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27302,7 +28170,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 8: p.EnterOuterAlt(localctx, 8) - p.SetState(2055) + p.SetState(2126) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27311,11 +28179,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2052) + p.SetState(2123) p.Annotation() } - p.SetState(2057) + p.SetState(2128) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27323,10 +28191,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2058) + p.SetState(2129) p.RollbackStatement() } - p.SetState(2060) + p.SetState(2131) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27335,7 +28203,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2059) + p.SetState(2130) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27347,7 +28215,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 9: p.EnterOuterAlt(localctx, 9) - p.SetState(2065) + p.SetState(2136) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27356,11 +28224,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2062) + p.SetState(2133) p.Annotation() } - p.SetState(2067) + p.SetState(2138) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27368,10 +28236,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2068) + p.SetState(2139) p.RetrieveStatement() } - p.SetState(2070) + p.SetState(2141) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27380,7 +28248,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2069) + p.SetState(2140) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27392,7 +28260,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 10: p.EnterOuterAlt(localctx, 10) - p.SetState(2075) + p.SetState(2146) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27401,11 +28269,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2072) + p.SetState(2143) p.Annotation() } - p.SetState(2077) + p.SetState(2148) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27413,10 +28281,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2078) + p.SetState(2149) p.IfStatement() } - p.SetState(2080) + p.SetState(2151) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27425,7 +28293,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2079) + p.SetState(2150) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27437,7 +28305,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 11: p.EnterOuterAlt(localctx, 11) - p.SetState(2085) + p.SetState(2156) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27446,11 +28314,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2082) + p.SetState(2153) p.Annotation() } - p.SetState(2087) + p.SetState(2158) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27458,10 +28326,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2088) + p.SetState(2159) p.LoopStatement() } - p.SetState(2090) + p.SetState(2161) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27470,7 +28338,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2089) + p.SetState(2160) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27482,7 +28350,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 12: p.EnterOuterAlt(localctx, 12) - p.SetState(2095) + p.SetState(2166) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27491,11 +28359,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2092) + p.SetState(2163) p.Annotation() } - p.SetState(2097) + p.SetState(2168) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27503,10 +28371,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2098) + p.SetState(2169) p.WhileStatement() } - p.SetState(2100) + p.SetState(2171) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27515,7 +28383,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2099) + p.SetState(2170) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27527,7 +28395,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 13: p.EnterOuterAlt(localctx, 13) - p.SetState(2105) + p.SetState(2176) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27536,11 +28404,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2102) + p.SetState(2173) p.Annotation() } - p.SetState(2107) + p.SetState(2178) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27548,10 +28416,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2108) + p.SetState(2179) p.ContinueStatement() } - p.SetState(2110) + p.SetState(2181) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27560,7 +28428,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2109) + p.SetState(2180) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27572,7 +28440,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 14: p.EnterOuterAlt(localctx, 14) - p.SetState(2115) + p.SetState(2186) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27581,11 +28449,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2112) + p.SetState(2183) p.Annotation() } - p.SetState(2117) + p.SetState(2188) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27593,10 +28461,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2118) + p.SetState(2189) p.BreakStatement() } - p.SetState(2120) + p.SetState(2191) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27605,7 +28473,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2119) + p.SetState(2190) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27617,7 +28485,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 15: p.EnterOuterAlt(localctx, 15) - p.SetState(2125) + p.SetState(2196) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27626,11 +28494,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2122) + p.SetState(2193) p.Annotation() } - p.SetState(2127) + p.SetState(2198) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27638,10 +28506,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2128) + p.SetState(2199) p.ReturnStatement() } - p.SetState(2130) + p.SetState(2201) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27650,7 +28518,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2129) + p.SetState(2200) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27662,7 +28530,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 16: p.EnterOuterAlt(localctx, 16) - p.SetState(2135) + p.SetState(2206) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27671,11 +28539,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2132) + p.SetState(2203) p.Annotation() } - p.SetState(2137) + p.SetState(2208) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27683,10 +28551,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2138) + p.SetState(2209) p.RaiseErrorStatement() } - p.SetState(2140) + p.SetState(2211) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27695,7 +28563,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2139) + p.SetState(2210) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27707,7 +28575,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 17: p.EnterOuterAlt(localctx, 17) - p.SetState(2145) + p.SetState(2216) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27716,11 +28584,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2142) + p.SetState(2213) p.Annotation() } - p.SetState(2147) + p.SetState(2218) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27728,10 +28596,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2148) + p.SetState(2219) p.LogStatement() } - p.SetState(2150) + p.SetState(2221) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27740,7 +28608,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2149) + p.SetState(2220) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27752,7 +28620,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 18: p.EnterOuterAlt(localctx, 18) - p.SetState(2155) + p.SetState(2226) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27761,11 +28629,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2152) + p.SetState(2223) p.Annotation() } - p.SetState(2157) + p.SetState(2228) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27773,10 +28641,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2158) + p.SetState(2229) p.CallMicroflowStatement() } - p.SetState(2160) + p.SetState(2231) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27785,7 +28653,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2159) + p.SetState(2230) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27797,7 +28665,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 19: p.EnterOuterAlt(localctx, 19) - p.SetState(2165) + p.SetState(2236) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27806,11 +28674,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2162) + p.SetState(2233) p.Annotation() } - p.SetState(2167) + p.SetState(2238) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27818,10 +28686,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2168) + p.SetState(2239) p.CallJavaActionStatement() } - p.SetState(2170) + p.SetState(2241) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27830,7 +28698,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2169) + p.SetState(2240) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27842,7 +28710,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 20: p.EnterOuterAlt(localctx, 20) - p.SetState(2175) + p.SetState(2246) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27851,11 +28719,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2172) + p.SetState(2243) p.Annotation() } - p.SetState(2177) + p.SetState(2248) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27863,10 +28731,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2178) + p.SetState(2249) p.ExecuteDatabaseQueryStatement() } - p.SetState(2180) + p.SetState(2251) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27875,7 +28743,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2179) + p.SetState(2250) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27887,7 +28755,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 21: p.EnterOuterAlt(localctx, 21) - p.SetState(2185) + p.SetState(2256) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27896,11 +28764,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2182) + p.SetState(2253) p.Annotation() } - p.SetState(2187) + p.SetState(2258) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27908,10 +28776,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2188) + p.SetState(2259) p.CallExternalActionStatement() } - p.SetState(2190) + p.SetState(2261) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27920,7 +28788,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2189) + p.SetState(2260) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27932,7 +28800,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 22: p.EnterOuterAlt(localctx, 22) - p.SetState(2195) + p.SetState(2266) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27941,11 +28809,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2192) + p.SetState(2263) p.Annotation() } - p.SetState(2197) + p.SetState(2268) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27953,10 +28821,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2198) + p.SetState(2269) p.ShowPageStatement() } - p.SetState(2200) + p.SetState(2271) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27965,7 +28833,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2199) + p.SetState(2270) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -27977,7 +28845,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 23: p.EnterOuterAlt(localctx, 23) - p.SetState(2205) + p.SetState(2276) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27986,11 +28854,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2202) + p.SetState(2273) p.Annotation() } - p.SetState(2207) + p.SetState(2278) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27998,10 +28866,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2208) + p.SetState(2279) p.ClosePageStatement() } - p.SetState(2210) + p.SetState(2281) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28010,7 +28878,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2209) + p.SetState(2280) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28022,7 +28890,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 24: p.EnterOuterAlt(localctx, 24) - p.SetState(2215) + p.SetState(2286) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28031,11 +28899,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2212) + p.SetState(2283) p.Annotation() } - p.SetState(2217) + p.SetState(2288) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28043,10 +28911,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2218) + p.SetState(2289) p.ShowHomePageStatement() } - p.SetState(2220) + p.SetState(2291) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28055,7 +28923,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2219) + p.SetState(2290) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28067,7 +28935,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 25: p.EnterOuterAlt(localctx, 25) - p.SetState(2225) + p.SetState(2296) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28076,11 +28944,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2222) + p.SetState(2293) p.Annotation() } - p.SetState(2227) + p.SetState(2298) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28088,10 +28956,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2228) + p.SetState(2299) p.ShowMessageStatement() } - p.SetState(2230) + p.SetState(2301) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28100,7 +28968,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2229) + p.SetState(2300) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28112,7 +28980,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 26: p.EnterOuterAlt(localctx, 26) - p.SetState(2235) + p.SetState(2306) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28121,11 +28989,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2232) + p.SetState(2303) p.Annotation() } - p.SetState(2237) + p.SetState(2308) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28133,10 +29001,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2238) + p.SetState(2309) p.ThrowStatement() } - p.SetState(2240) + p.SetState(2311) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28145,7 +29013,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2239) + p.SetState(2310) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28157,7 +29025,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 27: p.EnterOuterAlt(localctx, 27) - p.SetState(2245) + p.SetState(2316) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28166,11 +29034,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2242) + p.SetState(2313) p.Annotation() } - p.SetState(2247) + p.SetState(2318) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28178,10 +29046,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2248) + p.SetState(2319) p.ListOperationStatement() } - p.SetState(2250) + p.SetState(2321) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28190,7 +29058,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2249) + p.SetState(2320) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28202,7 +29070,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 28: p.EnterOuterAlt(localctx, 28) - p.SetState(2255) + p.SetState(2326) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28211,11 +29079,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2252) + p.SetState(2323) p.Annotation() } - p.SetState(2257) + p.SetState(2328) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28223,10 +29091,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2258) + p.SetState(2329) p.AggregateListStatement() } - p.SetState(2260) + p.SetState(2331) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28235,7 +29103,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2259) + p.SetState(2330) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28247,7 +29115,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 29: p.EnterOuterAlt(localctx, 29) - p.SetState(2265) + p.SetState(2336) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28256,11 +29124,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2262) + p.SetState(2333) p.Annotation() } - p.SetState(2267) + p.SetState(2338) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28268,10 +29136,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2268) + p.SetState(2339) p.AddToListStatement() } - p.SetState(2270) + p.SetState(2341) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28280,7 +29148,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2269) + p.SetState(2340) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28292,7 +29160,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 30: p.EnterOuterAlt(localctx, 30) - p.SetState(2275) + p.SetState(2346) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28301,11 +29169,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2272) + p.SetState(2343) p.Annotation() } - p.SetState(2277) + p.SetState(2348) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28313,10 +29181,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2278) + p.SetState(2349) p.RemoveFromListStatement() } - p.SetState(2280) + p.SetState(2351) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28325,7 +29193,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2279) + p.SetState(2350) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28337,7 +29205,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 31: p.EnterOuterAlt(localctx, 31) - p.SetState(2285) + p.SetState(2356) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28346,11 +29214,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2282) + p.SetState(2353) p.Annotation() } - p.SetState(2287) + p.SetState(2358) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28358,10 +29226,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2288) + p.SetState(2359) p.ValidationFeedbackStatement() } - p.SetState(2290) + p.SetState(2361) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28370,7 +29238,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2289) + p.SetState(2360) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28382,7 +29250,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { case 32: p.EnterOuterAlt(localctx, 32) - p.SetState(2295) + p.SetState(2366) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28391,11 +29259,11 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { for _la == MDLParserAT { { - p.SetState(2292) + p.SetState(2363) p.Annotation() } - p.SetState(2297) + p.SetState(2368) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28403,10 +29271,10 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2298) + p.SetState(2369) p.RestCallStatement() } - p.SetState(2300) + p.SetState(2371) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28415,7 +29283,7 @@ func (p *MDLParser) MicroflowStatement() (localctx IMicroflowStatementContext) { if _la == MDLParserSEMICOLON { { - p.SetState(2299) + p.SetState(2370) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -28558,12 +29426,12 @@ func (s *DeclareStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DeclareStatement() (localctx IDeclareStatementContext) { localctx = NewDeclareStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 184, MDLParserRULE_declareStatement) + p.EnterRule(localctx, 188, MDLParserRULE_declareStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2304) + p.SetState(2375) p.Match(MDLParserDECLARE) if p.HasError() { // Recognition error - abort rule @@ -28571,7 +29439,7 @@ func (p *MDLParser) DeclareStatement() (localctx IDeclareStatementContext) { } } { - p.SetState(2305) + p.SetState(2376) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -28579,10 +29447,10 @@ func (p *MDLParser) DeclareStatement() (localctx IDeclareStatementContext) { } } { - p.SetState(2306) + p.SetState(2377) p.DataType() } - p.SetState(2309) + p.SetState(2380) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28591,7 +29459,7 @@ func (p *MDLParser) DeclareStatement() (localctx IDeclareStatementContext) { if _la == MDLParserEQUALS { { - p.SetState(2307) + p.SetState(2378) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -28599,7 +29467,7 @@ func (p *MDLParser) DeclareStatement() (localctx IDeclareStatementContext) { } } { - p.SetState(2308) + p.SetState(2379) p.Expression() } @@ -28734,26 +29602,26 @@ func (s *SetStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SetStatement() (localctx ISetStatementContext) { localctx = NewSetStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 186, MDLParserRULE_setStatement) + p.EnterRule(localctx, 190, MDLParserRULE_setStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2311) + p.SetState(2382) p.Match(MDLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2314) + p.SetState(2385) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 214, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 217, p.GetParserRuleContext()) { case 1: { - p.SetState(2312) + p.SetState(2383) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -28763,7 +29631,7 @@ func (p *MDLParser) SetStatement() (localctx ISetStatementContext) { case 2: { - p.SetState(2313) + p.SetState(2384) p.AttributePath() } @@ -28771,7 +29639,7 @@ func (p *MDLParser) SetStatement() (localctx ISetStatementContext) { goto errorExit } { - p.SetState(2316) + p.SetState(2387) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -28779,7 +29647,7 @@ func (p *MDLParser) SetStatement() (localctx ISetStatementContext) { } } { - p.SetState(2317) + p.SetState(2388) p.Expression() } @@ -28939,11 +29807,11 @@ func (s *CreateObjectStatementContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementContext) { localctx = NewCreateObjectStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 188, MDLParserRULE_createObjectStatement) + p.EnterRule(localctx, 192, MDLParserRULE_createObjectStatement) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2321) + p.SetState(2392) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28952,7 +29820,7 @@ func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementCont if _la == MDLParserVARIABLE { { - p.SetState(2319) + p.SetState(2390) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -28960,7 +29828,7 @@ func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementCont } } { - p.SetState(2320) + p.SetState(2391) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -28970,7 +29838,7 @@ func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementCont } { - p.SetState(2323) + p.SetState(2394) p.Match(MDLParserCREATE) if p.HasError() { // Recognition error - abort rule @@ -28978,10 +29846,10 @@ func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementCont } } { - p.SetState(2324) + p.SetState(2395) p.NonListDataType() } - p.SetState(2330) + p.SetState(2401) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28990,29 +29858,29 @@ func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementCont if _la == MDLParserLPAREN { { - p.SetState(2325) + p.SetState(2396) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2327) + p.SetState(2398) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256446305633024) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&315150679595225079) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-468218264967741735) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-9217812889124471295) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&9223265382612328703) != 0) || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&-9007233614479601) != 0) || ((int64((_la-386)) & ^0x3f) == 0 && ((int64(1)<<(_la-386))&4611685824080116567) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&41943043) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256450600600320) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&315150679595225079) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-468218264967741735) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-9217812889124471295) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-247391730802433) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&-9007233614479601) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-194347271337) != 0) || ((int64((_la-451)) & ^0x3f) == 0 && ((int64(1)<<(_la-451))&22517999747692607) != 0) { { - p.SetState(2326) + p.SetState(2397) p.MemberAssignmentList() } } { - p.SetState(2329) + p.SetState(2400) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -29021,7 +29889,7 @@ func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementCont } } - p.SetState(2333) + p.SetState(2404) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29030,7 +29898,7 @@ func (p *MDLParser) CreateObjectStatement() (localctx ICreateObjectStatementCont if _la == MDLParserON { { - p.SetState(2332) + p.SetState(2403) p.OnErrorClause() } @@ -29153,12 +30021,12 @@ func (s *ChangeObjectStatementContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) ChangeObjectStatement() (localctx IChangeObjectStatementContext) { localctx = NewChangeObjectStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 190, MDLParserRULE_changeObjectStatement) + p.EnterRule(localctx, 194, MDLParserRULE_changeObjectStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2335) + p.SetState(2406) p.Match(MDLParserCHANGE) if p.HasError() { // Recognition error - abort rule @@ -29166,14 +30034,14 @@ func (p *MDLParser) ChangeObjectStatement() (localctx IChangeObjectStatementCont } } { - p.SetState(2336) + p.SetState(2407) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2342) + p.SetState(2413) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29182,29 +30050,29 @@ func (p *MDLParser) ChangeObjectStatement() (localctx IChangeObjectStatementCont if _la == MDLParserLPAREN { { - p.SetState(2337) + p.SetState(2408) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2339) + p.SetState(2410) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256446305633024) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&315150679595225079) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-468218264967741735) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-9217812889124471295) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&9223265382612328703) != 0) || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&-9007233614479601) != 0) || ((int64((_la-386)) & ^0x3f) == 0 && ((int64(1)<<(_la-386))&4611685824080116567) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&41943043) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256450600600320) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&315150679595225079) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-468218264967741735) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-9217812889124471295) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-247391730802433) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&-9007233614479601) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-194347271337) != 0) || ((int64((_la-451)) & ^0x3f) == 0 && ((int64(1)<<(_la-451))&22517999747692607) != 0) { { - p.SetState(2338) + p.SetState(2409) p.MemberAssignmentList() } } { - p.SetState(2341) + p.SetState(2412) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -29372,19 +30240,19 @@ func (s *AttributePathContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AttributePath() (localctx IAttributePathContext) { localctx = NewAttributePathContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 192, MDLParserRULE_attributePath) + p.EnterRule(localctx, 196, MDLParserRULE_attributePath) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2344) + p.SetState(2415) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2350) + p.SetState(2421) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29393,7 +30261,7 @@ func (p *MDLParser) AttributePath() (localctx IAttributePathContext) { for ok := true; ok; ok = _la == MDLParserSLASH || _la == MDLParserDOT { { - p.SetState(2345) + p.SetState(2416) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserSLASH || _la == MDLParserDOT) { @@ -29403,16 +30271,16 @@ func (p *MDLParser) AttributePath() (localctx IAttributePathContext) { p.Consume() } } - p.SetState(2348) + p.SetState(2419) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 221, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 224, p.GetParserRuleContext()) { case 1: { - p.SetState(2346) + p.SetState(2417) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -29422,7 +30290,7 @@ func (p *MDLParser) AttributePath() (localctx IAttributePathContext) { case 2: { - p.SetState(2347) + p.SetState(2418) p.QualifiedName() } @@ -29430,7 +30298,7 @@ func (p *MDLParser) AttributePath() (localctx IAttributePathContext) { goto errorExit } - p.SetState(2352) + p.SetState(2423) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29560,12 +30428,12 @@ func (s *CommitStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { localctx = NewCommitStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 194, MDLParserRULE_commitStatement) + p.EnterRule(localctx, 198, MDLParserRULE_commitStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2354) + p.SetState(2425) p.Match(MDLParserCOMMIT) if p.HasError() { // Recognition error - abort rule @@ -29573,14 +30441,14 @@ func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { } } { - p.SetState(2355) + p.SetState(2426) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2358) + p.SetState(2429) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29589,7 +30457,7 @@ func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { if _la == MDLParserWITH { { - p.SetState(2356) + p.SetState(2427) p.Match(MDLParserWITH) if p.HasError() { // Recognition error - abort rule @@ -29597,7 +30465,7 @@ func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { } } { - p.SetState(2357) + p.SetState(2428) p.Match(MDLParserEVENTS) if p.HasError() { // Recognition error - abort rule @@ -29606,7 +30474,7 @@ func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { } } - p.SetState(2361) + p.SetState(2432) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29615,7 +30483,7 @@ func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { if _la == MDLParserREFRESH { { - p.SetState(2360) + p.SetState(2431) p.Match(MDLParserREFRESH) if p.HasError() { // Recognition error - abort rule @@ -29624,7 +30492,7 @@ func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { } } - p.SetState(2364) + p.SetState(2435) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29633,7 +30501,7 @@ func (p *MDLParser) CommitStatement() (localctx ICommitStatementContext) { if _la == MDLParserON { { - p.SetState(2363) + p.SetState(2434) p.OnErrorClause() } @@ -29746,12 +30614,12 @@ func (s *DeleteObjectStatementContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) DeleteObjectStatement() (localctx IDeleteObjectStatementContext) { localctx = NewDeleteObjectStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 196, MDLParserRULE_deleteObjectStatement) + p.EnterRule(localctx, 200, MDLParserRULE_deleteObjectStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2366) + p.SetState(2437) p.Match(MDLParserDELETE) if p.HasError() { // Recognition error - abort rule @@ -29759,14 +30627,14 @@ func (p *MDLParser) DeleteObjectStatement() (localctx IDeleteObjectStatementCont } } { - p.SetState(2367) + p.SetState(2438) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2369) + p.SetState(2440) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29775,7 +30643,7 @@ func (p *MDLParser) DeleteObjectStatement() (localctx IDeleteObjectStatementCont if _la == MDLParserON { { - p.SetState(2368) + p.SetState(2439) p.OnErrorClause() } @@ -29876,12 +30744,12 @@ func (s *RollbackStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RollbackStatement() (localctx IRollbackStatementContext) { localctx = NewRollbackStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 198, MDLParserRULE_rollbackStatement) + p.EnterRule(localctx, 202, MDLParserRULE_rollbackStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2371) + p.SetState(2442) p.Match(MDLParserROLLBACK) if p.HasError() { // Recognition error - abort rule @@ -29889,14 +30757,14 @@ func (p *MDLParser) RollbackStatement() (localctx IRollbackStatementContext) { } } { - p.SetState(2372) + p.SetState(2443) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2374) + p.SetState(2445) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29905,7 +30773,7 @@ func (p *MDLParser) RollbackStatement() (localctx IRollbackStatementContext) { if _la == MDLParserREFRESH { { - p.SetState(2373) + p.SetState(2444) p.Match(MDLParserREFRESH) if p.HasError() { // Recognition error - abort rule @@ -30199,12 +31067,12 @@ func (s *RetrieveStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { localctx = NewRetrieveStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 200, MDLParserRULE_retrieveStatement) + p.EnterRule(localctx, 204, MDLParserRULE_retrieveStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2376) + p.SetState(2447) p.Match(MDLParserRETRIEVE) if p.HasError() { // Recognition error - abort rule @@ -30212,7 +31080,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } { - p.SetState(2377) + p.SetState(2448) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -30220,7 +31088,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } { - p.SetState(2378) + p.SetState(2449) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -30228,10 +31096,10 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } { - p.SetState(2379) + p.SetState(2450) p.RetrieveSource() } - p.SetState(2385) + p.SetState(2456) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30240,14 +31108,14 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { if _la == MDLParserWHERE { { - p.SetState(2380) + p.SetState(2451) p.Match(MDLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2383) + p.SetState(2454) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30256,13 +31124,13 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { switch p.GetTokenStream().LA(1) { case MDLParserLBRACKET: { - p.SetState(2381) + p.SetState(2452) p.XpathConstraint() } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: { - p.SetState(2382) + p.SetState(2453) p.Expression() } @@ -30272,7 +31140,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } - p.SetState(2396) + p.SetState(2467) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30281,7 +31149,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { if _la == MDLParserSORT_BY { { - p.SetState(2387) + p.SetState(2458) p.Match(MDLParserSORT_BY) if p.HasError() { // Recognition error - abort rule @@ -30289,10 +31157,10 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } { - p.SetState(2388) + p.SetState(2459) p.SortColumn() } - p.SetState(2393) + p.SetState(2464) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30301,7 +31169,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { for _la == MDLParserCOMMA { { - p.SetState(2389) + p.SetState(2460) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -30309,11 +31177,11 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } { - p.SetState(2390) + p.SetState(2461) p.SortColumn() } - p.SetState(2395) + p.SetState(2466) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30322,7 +31190,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } - p.SetState(2400) + p.SetState(2471) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30331,7 +31199,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { if _la == MDLParserLIMIT { { - p.SetState(2398) + p.SetState(2469) p.Match(MDLParserLIMIT) if p.HasError() { // Recognition error - abort rule @@ -30339,7 +31207,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } { - p.SetState(2399) + p.SetState(2470) var _x = p.Expression() @@ -30347,7 +31215,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } - p.SetState(2404) + p.SetState(2475) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30356,7 +31224,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { if _la == MDLParserOFFSET { { - p.SetState(2402) + p.SetState(2473) p.Match(MDLParserOFFSET) if p.HasError() { // Recognition error - abort rule @@ -30364,7 +31232,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } { - p.SetState(2403) + p.SetState(2474) var _x = p.Expression() @@ -30372,7 +31240,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { } } - p.SetState(2407) + p.SetState(2478) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30381,7 +31249,7 @@ func (p *MDLParser) RetrieveStatement() (localctx IRetrieveStatementContext) { if _la == MDLParserON { { - p.SetState(2406) + p.SetState(2477) p.OnErrorClause() } @@ -30521,25 +31389,25 @@ func (s *RetrieveSourceContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RetrieveSource() (localctx IRetrieveSourceContext) { localctx = NewRetrieveSourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 202, MDLParserRULE_retrieveSource) - p.SetState(2416) + p.EnterRule(localctx, 206, MDLParserRULE_retrieveSource) + p.SetState(2487) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 235, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 238, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2409) + p.SetState(2480) p.QualifiedName() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2410) + p.SetState(2481) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -30547,11 +31415,11 @@ func (p *MDLParser) RetrieveSource() (localctx IRetrieveSourceContext) { } } { - p.SetState(2411) + p.SetState(2482) p.OqlQuery() } { - p.SetState(2412) + p.SetState(2483) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -30562,7 +31430,7 @@ func (p *MDLParser) RetrieveSource() (localctx IRetrieveSourceContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(2414) + p.SetState(2485) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -30570,7 +31438,7 @@ func (p *MDLParser) RetrieveSource() (localctx IRetrieveSourceContext) { } } { - p.SetState(2415) + p.SetState(2486) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -30714,18 +31582,18 @@ func (s *OnErrorClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { localctx = NewOnErrorClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 204, MDLParserRULE_onErrorClause) - p.SetState(2438) + p.EnterRule(localctx, 208, MDLParserRULE_onErrorClause) + p.SetState(2509) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 236, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 239, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2418) + p.SetState(2489) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -30733,7 +31601,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2419) + p.SetState(2490) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -30741,7 +31609,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2420) + p.SetState(2491) p.Match(MDLParserCONTINUE) if p.HasError() { // Recognition error - abort rule @@ -30752,7 +31620,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2421) + p.SetState(2492) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -30760,7 +31628,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2422) + p.SetState(2493) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -30768,7 +31636,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2423) + p.SetState(2494) p.Match(MDLParserROLLBACK) if p.HasError() { // Recognition error - abort rule @@ -30779,7 +31647,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(2424) + p.SetState(2495) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -30787,7 +31655,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2425) + p.SetState(2496) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -30795,7 +31663,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2426) + p.SetState(2497) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -30803,11 +31671,11 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2427) + p.SetState(2498) p.MicroflowBody() } { - p.SetState(2428) + p.SetState(2499) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -30818,7 +31686,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(2430) + p.SetState(2501) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -30826,7 +31694,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2431) + p.SetState(2502) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -30834,7 +31702,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2432) + p.SetState(2503) p.Match(MDLParserWITHOUT) if p.HasError() { // Recognition error - abort rule @@ -30842,7 +31710,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2433) + p.SetState(2504) p.Match(MDLParserROLLBACK) if p.HasError() { // Recognition error - abort rule @@ -30850,7 +31718,7 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2434) + p.SetState(2505) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -30858,11 +31726,11 @@ func (p *MDLParser) OnErrorClause() (localctx IOnErrorClauseContext) { } } { - p.SetState(2435) + p.SetState(2506) p.MicroflowBody() } { - p.SetState(2436) + p.SetState(2507) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -31080,12 +31948,12 @@ func (s *IfStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { localctx = NewIfStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 206, MDLParserRULE_ifStatement) + p.EnterRule(localctx, 210, MDLParserRULE_ifStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2440) + p.SetState(2511) p.Match(MDLParserIF) if p.HasError() { // Recognition error - abort rule @@ -31093,11 +31961,11 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { } } { - p.SetState(2441) + p.SetState(2512) p.Expression() } { - p.SetState(2442) + p.SetState(2513) p.Match(MDLParserTHEN) if p.HasError() { // Recognition error - abort rule @@ -31105,10 +31973,10 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { } } { - p.SetState(2443) + p.SetState(2514) p.MicroflowBody() } - p.SetState(2451) + p.SetState(2522) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31117,7 +31985,7 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { for _la == MDLParserELSIF { { - p.SetState(2444) + p.SetState(2515) p.Match(MDLParserELSIF) if p.HasError() { // Recognition error - abort rule @@ -31125,11 +31993,11 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { } } { - p.SetState(2445) + p.SetState(2516) p.Expression() } { - p.SetState(2446) + p.SetState(2517) p.Match(MDLParserTHEN) if p.HasError() { // Recognition error - abort rule @@ -31137,18 +32005,18 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { } } { - p.SetState(2447) + p.SetState(2518) p.MicroflowBody() } - p.SetState(2453) + p.SetState(2524) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(2456) + p.SetState(2527) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31157,7 +32025,7 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { if _la == MDLParserELSE { { - p.SetState(2454) + p.SetState(2525) p.Match(MDLParserELSE) if p.HasError() { // Recognition error - abort rule @@ -31165,13 +32033,13 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { } } { - p.SetState(2455) + p.SetState(2526) p.MicroflowBody() } } { - p.SetState(2458) + p.SetState(2529) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule @@ -31179,7 +32047,7 @@ func (p *MDLParser) IfStatement() (localctx IIfStatementContext) { } } { - p.SetState(2459) + p.SetState(2530) p.Match(MDLParserIF) if p.HasError() { // Recognition error - abort rule @@ -31336,10 +32204,10 @@ func (s *LoopStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LoopStatement() (localctx ILoopStatementContext) { localctx = NewLoopStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 208, MDLParserRULE_loopStatement) + p.EnterRule(localctx, 212, MDLParserRULE_loopStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2461) + p.SetState(2532) p.Match(MDLParserLOOP) if p.HasError() { // Recognition error - abort rule @@ -31347,7 +32215,7 @@ func (p *MDLParser) LoopStatement() (localctx ILoopStatementContext) { } } { - p.SetState(2462) + p.SetState(2533) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -31355,23 +32223,23 @@ func (p *MDLParser) LoopStatement() (localctx ILoopStatementContext) { } } { - p.SetState(2463) + p.SetState(2534) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2466) + p.SetState(2537) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 239, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 242, p.GetParserRuleContext()) { case 1: { - p.SetState(2464) + p.SetState(2535) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -31381,7 +32249,7 @@ func (p *MDLParser) LoopStatement() (localctx ILoopStatementContext) { case 2: { - p.SetState(2465) + p.SetState(2536) p.AttributePath() } @@ -31389,7 +32257,7 @@ func (p *MDLParser) LoopStatement() (localctx ILoopStatementContext) { goto errorExit } { - p.SetState(2468) + p.SetState(2539) p.Match(MDLParserBEGIN) if p.HasError() { // Recognition error - abort rule @@ -31397,11 +32265,11 @@ func (p *MDLParser) LoopStatement() (localctx ILoopStatementContext) { } } { - p.SetState(2469) + p.SetState(2540) p.MicroflowBody() } { - p.SetState(2470) + p.SetState(2541) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule @@ -31409,7 +32277,7 @@ func (p *MDLParser) LoopStatement() (localctx ILoopStatementContext) { } } { - p.SetState(2471) + p.SetState(2542) p.Match(MDLParserLOOP) if p.HasError() { // Recognition error - abort rule @@ -31551,12 +32419,12 @@ func (s *WhileStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WhileStatement() (localctx IWhileStatementContext) { localctx = NewWhileStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 210, MDLParserRULE_whileStatement) + p.EnterRule(localctx, 214, MDLParserRULE_whileStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2473) + p.SetState(2544) p.Match(MDLParserWHILE) if p.HasError() { // Recognition error - abort rule @@ -31564,10 +32432,10 @@ func (p *MDLParser) WhileStatement() (localctx IWhileStatementContext) { } } { - p.SetState(2474) + p.SetState(2545) p.Expression() } - p.SetState(2476) + p.SetState(2547) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31576,7 +32444,7 @@ func (p *MDLParser) WhileStatement() (localctx IWhileStatementContext) { if _la == MDLParserBEGIN { { - p.SetState(2475) + p.SetState(2546) p.Match(MDLParserBEGIN) if p.HasError() { // Recognition error - abort rule @@ -31586,23 +32454,23 @@ func (p *MDLParser) WhileStatement() (localctx IWhileStatementContext) { } { - p.SetState(2478) + p.SetState(2549) p.MicroflowBody() } { - p.SetState(2479) + p.SetState(2550) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2481) + p.SetState(2552) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 241, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 244, p.GetParserRuleContext()) == 1 { { - p.SetState(2480) + p.SetState(2551) p.Match(MDLParserWHILE) if p.HasError() { // Recognition error - abort rule @@ -31699,10 +32567,10 @@ func (s *ContinueStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ContinueStatement() (localctx IContinueStatementContext) { localctx = NewContinueStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 212, MDLParserRULE_continueStatement) + p.EnterRule(localctx, 216, MDLParserRULE_continueStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2483) + p.SetState(2554) p.Match(MDLParserCONTINUE) if p.HasError() { // Recognition error - abort rule @@ -31795,10 +32663,10 @@ func (s *BreakStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) BreakStatement() (localctx IBreakStatementContext) { localctx = NewBreakStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 214, MDLParserRULE_breakStatement) + p.EnterRule(localctx, 218, MDLParserRULE_breakStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2485) + p.SetState(2556) p.Match(MDLParserBREAK) if p.HasError() { // Recognition error - abort rule @@ -31908,22 +32776,22 @@ func (s *ReturnStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ReturnStatement() (localctx IReturnStatementContext) { localctx = NewReturnStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 216, MDLParserRULE_returnStatement) + p.EnterRule(localctx, 220, MDLParserRULE_returnStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2487) + p.SetState(2558) p.Match(MDLParserRETURN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2489) + p.SetState(2560) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 242, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 245, p.GetParserRuleContext()) == 1 { { - p.SetState(2488) + p.SetState(2559) p.Expression() } @@ -32021,10 +32889,10 @@ func (s *RaiseErrorStatementContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) RaiseErrorStatement() (localctx IRaiseErrorStatementContext) { localctx = NewRaiseErrorStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 218, MDLParserRULE_raiseErrorStatement) + p.EnterRule(localctx, 222, MDLParserRULE_raiseErrorStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2491) + p.SetState(2562) p.Match(MDLParserRAISE) if p.HasError() { // Recognition error - abort rule @@ -32032,7 +32900,7 @@ func (p *MDLParser) RaiseErrorStatement() (localctx IRaiseErrorStatementContext) } } { - p.SetState(2492) + p.SetState(2563) p.Match(MDLParserERROR) if p.HasError() { // Recognition error - abort rule @@ -32186,31 +33054,31 @@ func (s *LogStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LogStatement() (localctx ILogStatementContext) { localctx = NewLogStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 220, MDLParserRULE_logStatement) + p.EnterRule(localctx, 224, MDLParserRULE_logStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2494) + p.SetState(2565) p.Match(MDLParserLOG) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2496) + p.SetState(2567) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 243, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 246, p.GetParserRuleContext()) == 1 { { - p.SetState(2495) + p.SetState(2566) p.LogLevel() } } else if p.HasError() { // JIM goto errorExit } - p.SetState(2500) + p.SetState(2571) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32219,7 +33087,7 @@ func (p *MDLParser) LogStatement() (localctx ILogStatementContext) { if _la == MDLParserNODE { { - p.SetState(2498) + p.SetState(2569) p.Match(MDLParserNODE) if p.HasError() { // Recognition error - abort rule @@ -32227,7 +33095,7 @@ func (p *MDLParser) LogStatement() (localctx ILogStatementContext) { } } { - p.SetState(2499) + p.SetState(2570) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -32237,10 +33105,10 @@ func (p *MDLParser) LogStatement() (localctx ILogStatementContext) { } { - p.SetState(2502) + p.SetState(2573) p.Expression() } - p.SetState(2504) + p.SetState(2575) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32249,7 +33117,7 @@ func (p *MDLParser) LogStatement() (localctx ILogStatementContext) { if _la == MDLParserWITH || _la == MDLParserPARAMETERS { { - p.SetState(2503) + p.SetState(2574) p.LogTemplateParams() } @@ -32365,12 +33233,12 @@ func (s *LogLevelContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LogLevel() (localctx ILogLevelContext) { localctx = NewLogLevelContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 222, MDLParserRULE_logLevel) + p.EnterRule(localctx, 226, MDLParserRULE_logLevel) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2506) + p.SetState(2577) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserDEBUG || ((int64((_la-133)) & ^0x3f) == 0 && ((int64(1)<<(_la-133))&15) != 0) || _la == MDLParserERROR) { @@ -32551,10 +33419,10 @@ func (s *TemplateParamsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { localctx = NewTemplateParamsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 224, MDLParserRULE_templateParams) + p.EnterRule(localctx, 228, MDLParserRULE_templateParams) var _la int - p.SetState(2522) + p.SetState(2593) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32564,7 +33432,7 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { case MDLParserWITH: p.EnterOuterAlt(localctx, 1) { - p.SetState(2508) + p.SetState(2579) p.Match(MDLParserWITH) if p.HasError() { // Recognition error - abort rule @@ -32572,7 +33440,7 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { } } { - p.SetState(2509) + p.SetState(2580) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -32580,10 +33448,10 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { } } { - p.SetState(2510) + p.SetState(2581) p.TemplateParam() } - p.SetState(2515) + p.SetState(2586) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32592,7 +33460,7 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { for _la == MDLParserCOMMA { { - p.SetState(2511) + p.SetState(2582) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -32600,11 +33468,11 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { } } { - p.SetState(2512) + p.SetState(2583) p.TemplateParam() } - p.SetState(2517) + p.SetState(2588) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32612,7 +33480,7 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2518) + p.SetState(2589) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -32623,7 +33491,7 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { case MDLParserPARAMETERS: p.EnterOuterAlt(localctx, 2) { - p.SetState(2520) + p.SetState(2591) p.Match(MDLParserPARAMETERS) if p.HasError() { // Recognition error - abort rule @@ -32631,7 +33499,7 @@ func (p *MDLParser) TemplateParams() (localctx ITemplateParamsContext) { } } { - p.SetState(2521) + p.SetState(2592) p.ArrayLiteral() } @@ -32757,10 +33625,10 @@ func (s *TemplateParamContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) TemplateParam() (localctx ITemplateParamContext) { localctx = NewTemplateParamContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 226, MDLParserRULE_templateParam) + p.EnterRule(localctx, 230, MDLParserRULE_templateParam) p.EnterOuterAlt(localctx, 1) { - p.SetState(2524) + p.SetState(2595) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -32768,7 +33636,7 @@ func (p *MDLParser) TemplateParam() (localctx ITemplateParamContext) { } } { - p.SetState(2525) + p.SetState(2596) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -32776,7 +33644,7 @@ func (p *MDLParser) TemplateParam() (localctx ITemplateParamContext) { } } { - p.SetState(2526) + p.SetState(2597) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -32784,7 +33652,7 @@ func (p *MDLParser) TemplateParam() (localctx ITemplateParamContext) { } } { - p.SetState(2527) + p.SetState(2598) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -32792,7 +33660,7 @@ func (p *MDLParser) TemplateParam() (localctx ITemplateParamContext) { } } { - p.SetState(2528) + p.SetState(2599) p.Expression() } @@ -32893,10 +33761,10 @@ func (s *LogTemplateParamsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LogTemplateParams() (localctx ILogTemplateParamsContext) { localctx = NewLogTemplateParamsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 228, MDLParserRULE_logTemplateParams) + p.EnterRule(localctx, 232, MDLParserRULE_logTemplateParams) p.EnterOuterAlt(localctx, 1) { - p.SetState(2530) + p.SetState(2601) p.TemplateParams() } @@ -32997,10 +33865,10 @@ func (s *LogTemplateParamContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LogTemplateParam() (localctx ILogTemplateParamContext) { localctx = NewLogTemplateParamContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 230, MDLParserRULE_logTemplateParam) + p.EnterRule(localctx, 234, MDLParserRULE_logTemplateParam) p.EnterOuterAlt(localctx, 1) { - p.SetState(2532) + p.SetState(2603) p.TemplateParam() } @@ -33165,11 +34033,11 @@ func (s *CallMicroflowStatementContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) CallMicroflowStatement() (localctx ICallMicroflowStatementContext) { localctx = NewCallMicroflowStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 232, MDLParserRULE_callMicroflowStatement) + p.EnterRule(localctx, 236, MDLParserRULE_callMicroflowStatement) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2536) + p.SetState(2607) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33178,7 +34046,7 @@ func (p *MDLParser) CallMicroflowStatement() (localctx ICallMicroflowStatementCo if _la == MDLParserVARIABLE { { - p.SetState(2534) + p.SetState(2605) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -33186,7 +34054,7 @@ func (p *MDLParser) CallMicroflowStatement() (localctx ICallMicroflowStatementCo } } { - p.SetState(2535) + p.SetState(2606) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -33196,7 +34064,7 @@ func (p *MDLParser) CallMicroflowStatement() (localctx ICallMicroflowStatementCo } { - p.SetState(2538) + p.SetState(2609) p.Match(MDLParserCALL) if p.HasError() { // Recognition error - abort rule @@ -33204,7 +34072,7 @@ func (p *MDLParser) CallMicroflowStatement() (localctx ICallMicroflowStatementCo } } { - p.SetState(2539) + p.SetState(2610) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -33212,40 +34080,40 @@ func (p *MDLParser) CallMicroflowStatement() (localctx ICallMicroflowStatementCo } } { - p.SetState(2540) + p.SetState(2611) p.QualifiedName() } { - p.SetState(2541) + p.SetState(2612) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2543) + p.SetState(2614) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-481)) & ^0x3f) == 0 && ((int64(1)<<(_la-481))&11) != 0) { + if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&11) != 0) { { - p.SetState(2542) + p.SetState(2613) p.CallArgumentList() } } { - p.SetState(2545) + p.SetState(2616) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2547) + p.SetState(2618) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33254,7 +34122,7 @@ func (p *MDLParser) CallMicroflowStatement() (localctx ICallMicroflowStatementCo if _la == MDLParserON { { - p.SetState(2546) + p.SetState(2617) p.OnErrorClause() } @@ -33426,11 +34294,11 @@ func (s *CallJavaActionStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatementContext) { localctx = NewCallJavaActionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 234, MDLParserRULE_callJavaActionStatement) + p.EnterRule(localctx, 238, MDLParserRULE_callJavaActionStatement) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2551) + p.SetState(2622) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33439,7 +34307,7 @@ func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatement if _la == MDLParserVARIABLE { { - p.SetState(2549) + p.SetState(2620) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -33447,7 +34315,7 @@ func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatement } } { - p.SetState(2550) + p.SetState(2621) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -33457,7 +34325,7 @@ func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatement } { - p.SetState(2553) + p.SetState(2624) p.Match(MDLParserCALL) if p.HasError() { // Recognition error - abort rule @@ -33465,7 +34333,7 @@ func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatement } } { - p.SetState(2554) + p.SetState(2625) p.Match(MDLParserJAVA) if p.HasError() { // Recognition error - abort rule @@ -33473,7 +34341,7 @@ func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatement } } { - p.SetState(2555) + p.SetState(2626) p.Match(MDLParserACTION) if p.HasError() { // Recognition error - abort rule @@ -33481,40 +34349,40 @@ func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatement } } { - p.SetState(2556) + p.SetState(2627) p.QualifiedName() } { - p.SetState(2557) + p.SetState(2628) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2559) + p.SetState(2630) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-481)) & ^0x3f) == 0 && ((int64(1)<<(_la-481))&11) != 0) { + if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&11) != 0) { { - p.SetState(2558) + p.SetState(2629) p.CallArgumentList() } } { - p.SetState(2561) + p.SetState(2632) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2563) + p.SetState(2634) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33523,7 +34391,7 @@ func (p *MDLParser) CallJavaActionStatement() (localctx ICallJavaActionStatement if _la == MDLParserON { { - p.SetState(2562) + p.SetState(2633) p.OnErrorClause() } @@ -33768,11 +34636,11 @@ func (s *ExecuteDatabaseQueryStatementContext) ExitRule(listener antlr.ParseTree func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQueryStatementContext) { localctx = NewExecuteDatabaseQueryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 236, MDLParserRULE_executeDatabaseQueryStatement) + p.EnterRule(localctx, 240, MDLParserRULE_executeDatabaseQueryStatement) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2567) + p.SetState(2638) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33781,7 +34649,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu if _la == MDLParserVARIABLE { { - p.SetState(2565) + p.SetState(2636) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -33789,7 +34657,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } { - p.SetState(2566) + p.SetState(2637) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -33799,7 +34667,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } { - p.SetState(2569) + p.SetState(2640) p.Match(MDLParserEXECUTE) if p.HasError() { // Recognition error - abort rule @@ -33807,7 +34675,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } { - p.SetState(2570) + p.SetState(2641) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -33815,7 +34683,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } { - p.SetState(2571) + p.SetState(2642) p.Match(MDLParserQUERY) if p.HasError() { // Recognition error - abort rule @@ -33823,10 +34691,10 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } { - p.SetState(2572) + p.SetState(2643) p.QualifiedName() } - p.SetState(2579) + p.SetState(2650) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33835,23 +34703,23 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu if _la == MDLParserDYNAMIC { { - p.SetState(2573) + p.SetState(2644) p.Match(MDLParserDYNAMIC) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2577) + p.SetState(2648) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 255, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 258, p.GetParserRuleContext()) { case 1: { - p.SetState(2574) + p.SetState(2645) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -33861,7 +34729,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu case 2: { - p.SetState(2575) + p.SetState(2646) p.Match(MDLParserDOLLAR_STRING) if p.HasError() { // Recognition error - abort rule @@ -33871,7 +34739,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu case 3: { - p.SetState(2576) + p.SetState(2647) p.Expression() } @@ -33880,7 +34748,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } - p.SetState(2586) + p.SetState(2657) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33889,29 +34757,29 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu if _la == MDLParserLPAREN { { - p.SetState(2581) + p.SetState(2652) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2583) + p.SetState(2654) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-481)) & ^0x3f) == 0 && ((int64(1)<<(_la-481))&11) != 0) { + if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&11) != 0) { { - p.SetState(2582) + p.SetState(2653) p.CallArgumentList() } } { - p.SetState(2585) + p.SetState(2656) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -33920,7 +34788,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } - p.SetState(2594) + p.SetState(2665) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33929,7 +34797,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu if _la == MDLParserCONNECTION { { - p.SetState(2588) + p.SetState(2659) p.Match(MDLParserCONNECTION) if p.HasError() { // Recognition error - abort rule @@ -33937,29 +34805,29 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } { - p.SetState(2589) + p.SetState(2660) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2591) + p.SetState(2662) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-481)) & ^0x3f) == 0 && ((int64(1)<<(_la-481))&11) != 0) { + if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&11) != 0) { { - p.SetState(2590) + p.SetState(2661) p.CallArgumentList() } } { - p.SetState(2593) + p.SetState(2664) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -33968,7 +34836,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu } } - p.SetState(2597) + p.SetState(2668) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33977,7 +34845,7 @@ func (p *MDLParser) ExecuteDatabaseQueryStatement() (localctx IExecuteDatabaseQu if _la == MDLParserON { { - p.SetState(2596) + p.SetState(2667) p.OnErrorClause() } @@ -34149,11 +35017,11 @@ func (s *CallExternalActionStatementContext) ExitRule(listener antlr.ParseTreeLi func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionStatementContext) { localctx = NewCallExternalActionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 238, MDLParserRULE_callExternalActionStatement) + p.EnterRule(localctx, 242, MDLParserRULE_callExternalActionStatement) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2601) + p.SetState(2672) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34162,7 +35030,7 @@ func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionS if _la == MDLParserVARIABLE { { - p.SetState(2599) + p.SetState(2670) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -34170,7 +35038,7 @@ func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionS } } { - p.SetState(2600) + p.SetState(2671) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -34180,7 +35048,7 @@ func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionS } { - p.SetState(2603) + p.SetState(2674) p.Match(MDLParserCALL) if p.HasError() { // Recognition error - abort rule @@ -34188,7 +35056,7 @@ func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionS } } { - p.SetState(2604) + p.SetState(2675) p.Match(MDLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule @@ -34196,7 +35064,7 @@ func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionS } } { - p.SetState(2605) + p.SetState(2676) p.Match(MDLParserACTION) if p.HasError() { // Recognition error - abort rule @@ -34204,40 +35072,40 @@ func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionS } } { - p.SetState(2606) + p.SetState(2677) p.QualifiedName() } { - p.SetState(2607) + p.SetState(2678) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2609) + p.SetState(2680) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-481)) & ^0x3f) == 0 && ((int64(1)<<(_la-481))&11) != 0) { + if ((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&11) != 0) { { - p.SetState(2608) + p.SetState(2679) p.CallArgumentList() } } { - p.SetState(2611) + p.SetState(2682) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2613) + p.SetState(2684) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34246,7 +35114,7 @@ func (p *MDLParser) CallExternalActionStatement() (localctx ICallExternalActionS if _la == MDLParserON { { - p.SetState(2612) + p.SetState(2683) p.OnErrorClause() } @@ -34385,15 +35253,15 @@ func (s *CallArgumentListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CallArgumentList() (localctx ICallArgumentListContext) { localctx = NewCallArgumentListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 240, MDLParserRULE_callArgumentList) + p.EnterRule(localctx, 244, MDLParserRULE_callArgumentList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2615) + p.SetState(2686) p.CallArgument() } - p.SetState(2620) + p.SetState(2691) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34402,7 +35270,7 @@ func (p *MDLParser) CallArgumentList() (localctx ICallArgumentListContext) { for _la == MDLParserCOMMA { { - p.SetState(2616) + p.SetState(2687) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -34410,11 +35278,11 @@ func (p *MDLParser) CallArgumentList() (localctx ICallArgumentListContext) { } } { - p.SetState(2617) + p.SetState(2688) p.CallArgument() } - p.SetState(2622) + p.SetState(2693) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34546,9 +35414,9 @@ func (s *CallArgumentContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CallArgument() (localctx ICallArgumentContext) { localctx = NewCallArgumentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 242, MDLParserRULE_callArgument) + p.EnterRule(localctx, 246, MDLParserRULE_callArgument) p.EnterOuterAlt(localctx, 1) - p.SetState(2625) + p.SetState(2696) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34557,7 +35425,7 @@ func (p *MDLParser) CallArgument() (localctx ICallArgumentContext) { switch p.GetTokenStream().LA(1) { case MDLParserVARIABLE: { - p.SetState(2623) + p.SetState(2694) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -34567,7 +35435,7 @@ func (p *MDLParser) CallArgument() (localctx ICallArgumentContext) { case MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserDEBUG, MDLParserACTION, MDLParserSORT, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserTITLE, MDLParserLABEL, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserEDITABLE, MDLParserVISIBLE, MDLParserSUCCESS, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserERROR, MDLParserRANGE, MDLParserSTATUS, MDLParserVERSION, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserNAVIGATION, MDLParserHOME, MDLParserCHECK, MDLParserTEXT, MDLParserMESSAGE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserFORMAT, MDLParserROLE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserDESCRIPTION, MDLParserOFF, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: { - p.SetState(2624) + p.SetState(2695) p.ParameterName() } @@ -34576,7 +35444,7 @@ func (p *MDLParser) CallArgument() (localctx ICallArgumentContext) { goto errorExit } { - p.SetState(2627) + p.SetState(2698) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -34584,7 +35452,7 @@ func (p *MDLParser) CallArgument() (localctx ICallArgumentContext) { } } { - p.SetState(2628) + p.SetState(2699) p.Expression() } @@ -34754,12 +35622,12 @@ func (s *ShowPageStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { localctx = NewShowPageStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 244, MDLParserRULE_showPageStatement) + p.EnterRule(localctx, 248, MDLParserRULE_showPageStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2630) + p.SetState(2701) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -34767,7 +35635,7 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { } } { - p.SetState(2631) + p.SetState(2702) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -34775,10 +35643,10 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { } } { - p.SetState(2632) + p.SetState(2703) p.QualifiedName() } - p.SetState(2638) + p.SetState(2709) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34787,29 +35655,29 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { if _la == MDLParserLPAREN { { - p.SetState(2633) + p.SetState(2704) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2635) + p.SetState(2706) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256446305633024) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&315150679595225079) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-468218264967741735) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-9217812889124471295) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&9223265382612328703) != 0) || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&-9007233614479601) != 0) || ((int64((_la-386)) & ^0x3f) == 0 && ((int64(1)<<(_la-386))&4611685824080116567) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&46137347) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256450600600320) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&315150679595225079) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-468218264967741735) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-9217812889124471295) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-247391730802433) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&-9007233614479601) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-194347271337) != 0) || ((int64((_la-451)) & ^0x3f) == 0 && ((int64(1)<<(_la-451))&24769799561377855) != 0) { { - p.SetState(2634) + p.SetState(2705) p.ShowPageArgList() } } { - p.SetState(2637) + p.SetState(2708) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -34818,7 +35686,7 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { } } - p.SetState(2642) + p.SetState(2713) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34827,7 +35695,7 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { if _la == MDLParserFOR { { - p.SetState(2640) + p.SetState(2711) p.Match(MDLParserFOR) if p.HasError() { // Recognition error - abort rule @@ -34835,7 +35703,7 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { } } { - p.SetState(2641) + p.SetState(2712) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -34844,7 +35712,7 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { } } - p.SetState(2646) + p.SetState(2717) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34853,7 +35721,7 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { if _la == MDLParserWITH { { - p.SetState(2644) + p.SetState(2715) p.Match(MDLParserWITH) if p.HasError() { // Recognition error - abort rule @@ -34861,7 +35729,7 @@ func (p *MDLParser) ShowPageStatement() (localctx IShowPageStatementContext) { } } { - p.SetState(2645) + p.SetState(2716) p.MemberAssignmentList() } @@ -35000,15 +35868,15 @@ func (s *ShowPageArgListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ShowPageArgList() (localctx IShowPageArgListContext) { localctx = NewShowPageArgListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 246, MDLParserRULE_showPageArgList) + p.EnterRule(localctx, 250, MDLParserRULE_showPageArgList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2648) + p.SetState(2719) p.ShowPageArg() } - p.SetState(2653) + p.SetState(2724) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -35017,7 +35885,7 @@ func (p *MDLParser) ShowPageArgList() (localctx IShowPageArgListContext) { for _la == MDLParserCOMMA { { - p.SetState(2649) + p.SetState(2720) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -35025,11 +35893,11 @@ func (p *MDLParser) ShowPageArgList() (localctx IShowPageArgListContext) { } } { - p.SetState(2650) + p.SetState(2721) p.ShowPageArg() } - p.SetState(2655) + p.SetState(2726) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -35171,8 +36039,8 @@ func (s *ShowPageArgContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ShowPageArg() (localctx IShowPageArgContext) { localctx = NewShowPageArgContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 248, MDLParserRULE_showPageArg) - p.SetState(2666) + p.EnterRule(localctx, 252, MDLParserRULE_showPageArg) + p.SetState(2737) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -35182,7 +36050,7 @@ func (p *MDLParser) ShowPageArg() (localctx IShowPageArgContext) { case MDLParserVARIABLE: p.EnterOuterAlt(localctx, 1) { - p.SetState(2656) + p.SetState(2727) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -35190,23 +36058,23 @@ func (p *MDLParser) ShowPageArg() (localctx IShowPageArgContext) { } } { - p.SetState(2657) + p.SetState(2728) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2660) + p.SetState(2731) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 272, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 275, p.GetParserRuleContext()) { case 1: { - p.SetState(2658) + p.SetState(2729) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -35216,7 +36084,7 @@ func (p *MDLParser) ShowPageArg() (localctx IShowPageArgContext) { case 2: { - p.SetState(2659) + p.SetState(2730) p.Expression() } @@ -35224,14 +36092,14 @@ func (p *MDLParser) ShowPageArg() (localctx IShowPageArgContext) { goto errorExit } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(2662) + p.SetState(2733) p.IdentifierOrKeyword() } { - p.SetState(2663) + p.SetState(2734) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -35239,7 +36107,7 @@ func (p *MDLParser) ShowPageArg() (localctx IShowPageArgContext) { } } { - p.SetState(2664) + p.SetState(2735) p.Expression() } @@ -35338,10 +36206,10 @@ func (s *ClosePageStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ClosePageStatement() (localctx IClosePageStatementContext) { localctx = NewClosePageStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 250, MDLParserRULE_closePageStatement) + p.EnterRule(localctx, 254, MDLParserRULE_closePageStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2668) + p.SetState(2739) p.Match(MDLParserCLOSE) if p.HasError() { // Recognition error - abort rule @@ -35349,7 +36217,7 @@ func (p *MDLParser) ClosePageStatement() (localctx IClosePageStatementContext) { } } { - p.SetState(2669) + p.SetState(2740) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -35452,10 +36320,10 @@ func (s *ShowHomePageStatementContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) ShowHomePageStatement() (localctx IShowHomePageStatementContext) { localctx = NewShowHomePageStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 252, MDLParserRULE_showHomePageStatement) + p.EnterRule(localctx, 256, MDLParserRULE_showHomePageStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2671) + p.SetState(2742) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -35463,7 +36331,7 @@ func (p *MDLParser) ShowHomePageStatement() (localctx IShowHomePageStatementCont } } { - p.SetState(2672) + p.SetState(2743) p.Match(MDLParserHOME) if p.HasError() { // Recognition error - abort rule @@ -35471,7 +36339,7 @@ func (p *MDLParser) ShowHomePageStatement() (localctx IShowHomePageStatementCont } } { - p.SetState(2673) + p.SetState(2744) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -35640,12 +36508,12 @@ func (s *ShowMessageStatementContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContext) { localctx = NewShowMessageStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 254, MDLParserRULE_showMessageStatement) + p.EnterRule(localctx, 258, MDLParserRULE_showMessageStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2675) + p.SetState(2746) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -35653,7 +36521,7 @@ func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContex } } { - p.SetState(2676) + p.SetState(2747) p.Match(MDLParserMESSAGE) if p.HasError() { // Recognition error - abort rule @@ -35661,10 +36529,10 @@ func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContex } } { - p.SetState(2677) + p.SetState(2748) p.Expression() } - p.SetState(2680) + p.SetState(2751) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -35673,7 +36541,7 @@ func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContex if _la == MDLParserTYPE { { - p.SetState(2678) + p.SetState(2749) p.Match(MDLParserTYPE) if p.HasError() { // Recognition error - abort rule @@ -35681,12 +36549,12 @@ func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContex } } { - p.SetState(2679) + p.SetState(2750) p.IdentifierOrKeyword() } } - p.SetState(2687) + p.SetState(2758) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -35695,7 +36563,7 @@ func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContex if _la == MDLParserOBJECTS { { - p.SetState(2682) + p.SetState(2753) p.Match(MDLParserOBJECTS) if p.HasError() { // Recognition error - abort rule @@ -35703,7 +36571,7 @@ func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContex } } { - p.SetState(2683) + p.SetState(2754) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -35711,11 +36579,11 @@ func (p *MDLParser) ShowMessageStatement() (localctx IShowMessageStatementContex } } { - p.SetState(2684) + p.SetState(2755) p.ExpressionList() } { - p.SetState(2685) + p.SetState(2756) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -35827,10 +36695,10 @@ func (s *ThrowStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ThrowStatement() (localctx IThrowStatementContext) { localctx = NewThrowStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 256, MDLParserRULE_throwStatement) + p.EnterRule(localctx, 260, MDLParserRULE_throwStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2689) + p.SetState(2760) p.Match(MDLParserTHROW) if p.HasError() { // Recognition error - abort rule @@ -35838,7 +36706,7 @@ func (p *MDLParser) ThrowStatement() (localctx IThrowStatementContext) { } } { - p.SetState(2690) + p.SetState(2761) p.Expression() } @@ -36003,12 +36871,12 @@ func (s *ValidationFeedbackStatementContext) ExitRule(listener antlr.ParseTreeLi func (p *MDLParser) ValidationFeedbackStatement() (localctx IValidationFeedbackStatementContext) { localctx = NewValidationFeedbackStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 258, MDLParserRULE_validationFeedbackStatement) + p.EnterRule(localctx, 262, MDLParserRULE_validationFeedbackStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2692) + p.SetState(2763) p.Match(MDLParserVALIDATION) if p.HasError() { // Recognition error - abort rule @@ -36016,7 +36884,7 @@ func (p *MDLParser) ValidationFeedbackStatement() (localctx IValidationFeedbackS } } { - p.SetState(2693) + p.SetState(2764) p.Match(MDLParserFEEDBACK) if p.HasError() { // Recognition error - abort rule @@ -36024,11 +36892,11 @@ func (p *MDLParser) ValidationFeedbackStatement() (localctx IValidationFeedbackS } } { - p.SetState(2694) + p.SetState(2765) p.AttributePath() } { - p.SetState(2695) + p.SetState(2766) p.Match(MDLParserMESSAGE) if p.HasError() { // Recognition error - abort rule @@ -36036,10 +36904,10 @@ func (p *MDLParser) ValidationFeedbackStatement() (localctx IValidationFeedbackS } } { - p.SetState(2696) + p.SetState(2767) p.Expression() } - p.SetState(2702) + p.SetState(2773) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36048,7 +36916,7 @@ func (p *MDLParser) ValidationFeedbackStatement() (localctx IValidationFeedbackS if _la == MDLParserOBJECTS { { - p.SetState(2697) + p.SetState(2768) p.Match(MDLParserOBJECTS) if p.HasError() { // Recognition error - abort rule @@ -36056,7 +36924,7 @@ func (p *MDLParser) ValidationFeedbackStatement() (localctx IValidationFeedbackS } } { - p.SetState(2698) + p.SetState(2769) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -36064,11 +36932,11 @@ func (p *MDLParser) ValidationFeedbackStatement() (localctx IValidationFeedbackS } } { - p.SetState(2699) + p.SetState(2770) p.ExpressionList() } { - p.SetState(2700) + p.SetState(2771) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -36357,11 +37225,11 @@ func (s *RestCallStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { localctx = NewRestCallStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 260, MDLParserRULE_restCallStatement) + p.EnterRule(localctx, 264, MDLParserRULE_restCallStatement) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2706) + p.SetState(2777) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36370,7 +37238,7 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { if _la == MDLParserVARIABLE { { - p.SetState(2704) + p.SetState(2775) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -36378,7 +37246,7 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { } } { - p.SetState(2705) + p.SetState(2776) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -36388,7 +37256,7 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { } { - p.SetState(2708) + p.SetState(2779) p.Match(MDLParserREST) if p.HasError() { // Recognition error - abort rule @@ -36396,7 +37264,7 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { } } { - p.SetState(2709) + p.SetState(2780) p.Match(MDLParserCALL) if p.HasError() { // Recognition error - abort rule @@ -36404,14 +37272,14 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { } } { - p.SetState(2710) + p.SetState(2781) p.HttpMethod() } { - p.SetState(2711) + p.SetState(2782) p.RestCallUrl() } - p.SetState(2713) + p.SetState(2784) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36420,12 +37288,12 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { if _la == MDLParserWITH || _la == MDLParserPARAMETERS { { - p.SetState(2712) + p.SetState(2783) p.RestCallUrlParams() } } - p.SetState(2718) + p.SetState(2789) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36434,18 +37302,18 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { for _la == MDLParserHEADER { { - p.SetState(2715) + p.SetState(2786) p.RestCallHeaderClause() } - p.SetState(2720) + p.SetState(2791) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(2722) + p.SetState(2793) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36454,12 +37322,12 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { if _la == MDLParserAUTH { { - p.SetState(2721) + p.SetState(2792) p.RestCallAuthClause() } } - p.SetState(2725) + p.SetState(2796) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36468,12 +37336,12 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { if _la == MDLParserBODY { { - p.SetState(2724) + p.SetState(2795) p.RestCallBodyClause() } } - p.SetState(2728) + p.SetState(2799) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36482,16 +37350,16 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { if _la == MDLParserTIMEOUT { { - p.SetState(2727) + p.SetState(2798) p.RestCallTimeoutClause() } } { - p.SetState(2730) + p.SetState(2801) p.RestCallReturnsClause() } - p.SetState(2732) + p.SetState(2803) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -36500,7 +37368,7 @@ func (p *MDLParser) RestCallStatement() (localctx IRestCallStatementContext) { if _la == MDLParserON { { - p.SetState(2731) + p.SetState(2802) p.OnErrorClause() } @@ -36611,15 +37479,15 @@ func (s *HttpMethodContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) HttpMethod() (localctx IHttpMethodContext) { localctx = NewHttpMethodContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 262, MDLParserRULE_httpMethod) + p.EnterRule(localctx, 266, MDLParserRULE_httpMethod) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2734) + p.SetState(2805) _la = p.GetTokenStream().LA(1) - if !(_la == MDLParserDELETE || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&15) != 0)) { + if !(_la == MDLParserDELETE || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&15) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -36729,18 +37597,18 @@ func (s *RestCallUrlContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestCallUrl() (localctx IRestCallUrlContext) { localctx = NewRestCallUrlContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 264, MDLParserRULE_restCallUrl) - p.SetState(2738) + p.EnterRule(localctx, 268, MDLParserRULE_restCallUrl) + p.SetState(2809) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 284, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 287, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2736) + p.SetState(2807) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -36751,7 +37619,7 @@ func (p *MDLParser) RestCallUrl() (localctx IRestCallUrlContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2737) + p.SetState(2808) p.Expression() } @@ -36856,10 +37724,10 @@ func (s *RestCallUrlParamsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestCallUrlParams() (localctx IRestCallUrlParamsContext) { localctx = NewRestCallUrlParamsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 266, MDLParserRULE_restCallUrlParams) + p.EnterRule(localctx, 270, MDLParserRULE_restCallUrlParams) p.EnterOuterAlt(localctx, 1) { - p.SetState(2740) + p.SetState(2811) p.TemplateParams() } @@ -36980,12 +37848,12 @@ func (s *RestCallHeaderClauseContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) RestCallHeaderClause() (localctx IRestCallHeaderClauseContext) { localctx = NewRestCallHeaderClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 268, MDLParserRULE_restCallHeaderClause) + p.EnterRule(localctx, 272, MDLParserRULE_restCallHeaderClause) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2742) + p.SetState(2813) p.Match(MDLParserHEADER) if p.HasError() { // Recognition error - abort rule @@ -36993,7 +37861,7 @@ func (p *MDLParser) RestCallHeaderClause() (localctx IRestCallHeaderClauseContex } } { - p.SetState(2743) + p.SetState(2814) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserSTRING_LITERAL || _la == MDLParserIDENTIFIER) { @@ -37004,7 +37872,7 @@ func (p *MDLParser) RestCallHeaderClause() (localctx IRestCallHeaderClauseContex } } { - p.SetState(2744) + p.SetState(2815) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -37012,7 +37880,7 @@ func (p *MDLParser) RestCallHeaderClause() (localctx IRestCallHeaderClauseContex } } { - p.SetState(2745) + p.SetState(2816) p.Expression() } @@ -37154,10 +38022,10 @@ func (s *RestCallAuthClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestCallAuthClause() (localctx IRestCallAuthClauseContext) { localctx = NewRestCallAuthClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 270, MDLParserRULE_restCallAuthClause) + p.EnterRule(localctx, 274, MDLParserRULE_restCallAuthClause) p.EnterOuterAlt(localctx, 1) { - p.SetState(2747) + p.SetState(2818) p.Match(MDLParserAUTH) if p.HasError() { // Recognition error - abort rule @@ -37165,7 +38033,7 @@ func (p *MDLParser) RestCallAuthClause() (localctx IRestCallAuthClauseContext) { } } { - p.SetState(2748) + p.SetState(2819) p.Match(MDLParserBASIC) if p.HasError() { // Recognition error - abort rule @@ -37173,11 +38041,11 @@ func (p *MDLParser) RestCallAuthClause() (localctx IRestCallAuthClauseContext) { } } { - p.SetState(2749) + p.SetState(2820) p.Expression() } { - p.SetState(2750) + p.SetState(2821) p.Match(MDLParserPASSWORD) if p.HasError() { // Recognition error - abort rule @@ -37185,7 +38053,7 @@ func (p *MDLParser) RestCallAuthClause() (localctx IRestCallAuthClauseContext) { } } { - p.SetState(2751) + p.SetState(2822) p.Expression() } @@ -37345,20 +38213,20 @@ func (s *RestCallBodyClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { localctx = NewRestCallBodyClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 272, MDLParserRULE_restCallBodyClause) + p.EnterRule(localctx, 276, MDLParserRULE_restCallBodyClause) var _la int - p.SetState(2769) + p.SetState(2840) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 287, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 290, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2753) + p.SetState(2824) p.Match(MDLParserBODY) if p.HasError() { // Recognition error - abort rule @@ -37366,14 +38234,14 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { } } { - p.SetState(2754) + p.SetState(2825) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2756) + p.SetState(2827) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -37382,7 +38250,7 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { if _la == MDLParserWITH || _la == MDLParserPARAMETERS { { - p.SetState(2755) + p.SetState(2826) p.TemplateParams() } @@ -37391,7 +38259,7 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2758) + p.SetState(2829) p.Match(MDLParserBODY) if p.HasError() { // Recognition error - abort rule @@ -37399,10 +38267,10 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { } } { - p.SetState(2759) + p.SetState(2830) p.Expression() } - p.SetState(2761) + p.SetState(2832) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -37411,7 +38279,7 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { if _la == MDLParserWITH || _la == MDLParserPARAMETERS { { - p.SetState(2760) + p.SetState(2831) p.TemplateParams() } @@ -37420,7 +38288,7 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(2763) + p.SetState(2834) p.Match(MDLParserBODY) if p.HasError() { // Recognition error - abort rule @@ -37428,7 +38296,7 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { } } { - p.SetState(2764) + p.SetState(2835) p.Match(MDLParserMAPPING) if p.HasError() { // Recognition error - abort rule @@ -37436,11 +38304,11 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { } } { - p.SetState(2765) + p.SetState(2836) p.QualifiedName() } { - p.SetState(2766) + p.SetState(2837) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -37448,7 +38316,7 @@ func (p *MDLParser) RestCallBodyClause() (localctx IRestCallBodyClauseContext) { } } { - p.SetState(2767) + p.SetState(2838) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -37562,10 +38430,10 @@ func (s *RestCallTimeoutClauseContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) RestCallTimeoutClause() (localctx IRestCallTimeoutClauseContext) { localctx = NewRestCallTimeoutClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 274, MDLParserRULE_restCallTimeoutClause) + p.EnterRule(localctx, 278, MDLParserRULE_restCallTimeoutClause) p.EnterOuterAlt(localctx, 1) { - p.SetState(2771) + p.SetState(2842) p.Match(MDLParserTIMEOUT) if p.HasError() { // Recognition error - abort rule @@ -37573,7 +38441,7 @@ func (p *MDLParser) RestCallTimeoutClause() (localctx IRestCallTimeoutClauseCont } } { - p.SetState(2772) + p.SetState(2843) p.Expression() } @@ -37735,18 +38603,18 @@ func (s *RestCallReturnsClauseContext) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseContext) { localctx = NewRestCallReturnsClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 276, MDLParserRULE_restCallReturnsClause) - p.SetState(2788) + p.EnterRule(localctx, 280, MDLParserRULE_restCallReturnsClause) + p.SetState(2859) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 288, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 291, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2774) + p.SetState(2845) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -37754,7 +38622,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont } } { - p.SetState(2775) + p.SetState(2846) p.Match(MDLParserSTRING_TYPE) if p.HasError() { // Recognition error - abort rule @@ -37765,7 +38633,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2776) + p.SetState(2847) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -37773,7 +38641,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont } } { - p.SetState(2777) + p.SetState(2848) p.Match(MDLParserRESPONSE) if p.HasError() { // Recognition error - abort rule @@ -37784,7 +38652,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(2778) + p.SetState(2849) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -37792,7 +38660,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont } } { - p.SetState(2779) + p.SetState(2850) p.Match(MDLParserMAPPING) if p.HasError() { // Recognition error - abort rule @@ -37800,11 +38668,11 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont } } { - p.SetState(2780) + p.SetState(2851) p.QualifiedName() } { - p.SetState(2781) + p.SetState(2852) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -37812,14 +38680,14 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont } } { - p.SetState(2782) + p.SetState(2853) p.QualifiedName() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(2784) + p.SetState(2855) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -37827,7 +38695,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont } } { - p.SetState(2785) + p.SetState(2856) p.Match(MDLParserNONE) if p.HasError() { // Recognition error - abort rule @@ -37838,7 +38706,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(2786) + p.SetState(2857) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -37846,7 +38714,7 @@ func (p *MDLParser) RestCallReturnsClause() (localctx IRestCallReturnsClauseCont } } { - p.SetState(2787) + p.SetState(2858) p.Match(MDLParserNOTHING) if p.HasError() { // Recognition error - abort rule @@ -37965,10 +38833,10 @@ func (s *ListOperationStatementContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) ListOperationStatement() (localctx IListOperationStatementContext) { localctx = NewListOperationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 278, MDLParserRULE_listOperationStatement) + p.EnterRule(localctx, 282, MDLParserRULE_listOperationStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2790) + p.SetState(2861) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -37976,7 +38844,7 @@ func (p *MDLParser) ListOperationStatement() (localctx IListOperationStatementCo } } { - p.SetState(2791) + p.SetState(2862) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -37984,7 +38852,7 @@ func (p *MDLParser) ListOperationStatement() (localctx IListOperationStatementCo } } { - p.SetState(2792) + p.SetState(2863) p.ListOperation() } @@ -38177,8 +39045,8 @@ func (s *ListOperationContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ListOperation() (localctx IListOperationContext) { localctx = NewListOperationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 280, MDLParserRULE_listOperation) - p.SetState(2853) + p.EnterRule(localctx, 284, MDLParserRULE_listOperation) + p.SetState(2924) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38188,7 +39056,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserHEAD: p.EnterOuterAlt(localctx, 1) { - p.SetState(2794) + p.SetState(2865) p.Match(MDLParserHEAD) if p.HasError() { // Recognition error - abort rule @@ -38196,7 +39064,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2795) + p.SetState(2866) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38204,7 +39072,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2796) + p.SetState(2867) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38212,7 +39080,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2797) + p.SetState(2868) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38223,7 +39091,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserTAIL: p.EnterOuterAlt(localctx, 2) { - p.SetState(2798) + p.SetState(2869) p.Match(MDLParserTAIL) if p.HasError() { // Recognition error - abort rule @@ -38231,7 +39099,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2799) + p.SetState(2870) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38239,7 +39107,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2800) + p.SetState(2871) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38247,7 +39115,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2801) + p.SetState(2872) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38258,7 +39126,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserFIND: p.EnterOuterAlt(localctx, 3) { - p.SetState(2802) + p.SetState(2873) p.Match(MDLParserFIND) if p.HasError() { // Recognition error - abort rule @@ -38266,7 +39134,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2803) + p.SetState(2874) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38274,7 +39142,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2804) + p.SetState(2875) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38282,7 +39150,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2805) + p.SetState(2876) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38290,11 +39158,11 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2806) + p.SetState(2877) p.Expression() } { - p.SetState(2807) + p.SetState(2878) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38305,7 +39173,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserFILTER: p.EnterOuterAlt(localctx, 4) { - p.SetState(2809) + p.SetState(2880) p.Match(MDLParserFILTER) if p.HasError() { // Recognition error - abort rule @@ -38313,7 +39181,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2810) + p.SetState(2881) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38321,7 +39189,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2811) + p.SetState(2882) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38329,7 +39197,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2812) + p.SetState(2883) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38337,11 +39205,11 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2813) + p.SetState(2884) p.Expression() } { - p.SetState(2814) + p.SetState(2885) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38352,7 +39220,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserSORT: p.EnterOuterAlt(localctx, 5) { - p.SetState(2816) + p.SetState(2887) p.Match(MDLParserSORT) if p.HasError() { // Recognition error - abort rule @@ -38360,7 +39228,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2817) + p.SetState(2888) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38368,7 +39236,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2818) + p.SetState(2889) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38376,7 +39244,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2819) + p.SetState(2890) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38384,11 +39252,11 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2820) + p.SetState(2891) p.SortSpecList() } { - p.SetState(2821) + p.SetState(2892) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38399,7 +39267,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserUNION: p.EnterOuterAlt(localctx, 6) { - p.SetState(2823) + p.SetState(2894) p.Match(MDLParserUNION) if p.HasError() { // Recognition error - abort rule @@ -38407,7 +39275,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2824) + p.SetState(2895) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38415,7 +39283,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2825) + p.SetState(2896) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38423,7 +39291,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2826) + p.SetState(2897) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38431,7 +39299,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2827) + p.SetState(2898) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38439,7 +39307,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2828) + p.SetState(2899) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38450,7 +39318,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserINTERSECT: p.EnterOuterAlt(localctx, 7) { - p.SetState(2829) + p.SetState(2900) p.Match(MDLParserINTERSECT) if p.HasError() { // Recognition error - abort rule @@ -38458,7 +39326,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2830) + p.SetState(2901) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38466,7 +39334,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2831) + p.SetState(2902) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38474,7 +39342,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2832) + p.SetState(2903) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38482,7 +39350,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2833) + p.SetState(2904) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38490,7 +39358,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2834) + p.SetState(2905) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38501,7 +39369,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserSUBTRACT: p.EnterOuterAlt(localctx, 8) { - p.SetState(2835) + p.SetState(2906) p.Match(MDLParserSUBTRACT) if p.HasError() { // Recognition error - abort rule @@ -38509,7 +39377,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2836) + p.SetState(2907) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38517,7 +39385,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2837) + p.SetState(2908) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38525,7 +39393,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2838) + p.SetState(2909) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38533,7 +39401,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2839) + p.SetState(2910) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38541,7 +39409,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2840) + p.SetState(2911) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38552,7 +39420,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserCONTAINS: p.EnterOuterAlt(localctx, 9) { - p.SetState(2841) + p.SetState(2912) p.Match(MDLParserCONTAINS) if p.HasError() { // Recognition error - abort rule @@ -38560,7 +39428,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2842) + p.SetState(2913) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38568,7 +39436,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2843) + p.SetState(2914) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38576,7 +39444,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2844) + p.SetState(2915) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38584,7 +39452,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2845) + p.SetState(2916) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38592,7 +39460,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2846) + p.SetState(2917) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38603,7 +39471,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { case MDLParserEQUALS_OP: p.EnterOuterAlt(localctx, 10) { - p.SetState(2847) + p.SetState(2918) p.Match(MDLParserEQUALS_OP) if p.HasError() { // Recognition error - abort rule @@ -38611,7 +39479,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2848) + p.SetState(2919) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -38619,7 +39487,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2849) + p.SetState(2920) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38627,7 +39495,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2850) + p.SetState(2921) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38635,7 +39503,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2851) + p.SetState(2922) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -38643,7 +39511,7 @@ func (p *MDLParser) ListOperation() (localctx IListOperationContext) { } } { - p.SetState(2852) + p.SetState(2923) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -38789,15 +39657,15 @@ func (s *SortSpecListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SortSpecList() (localctx ISortSpecListContext) { localctx = NewSortSpecListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 282, MDLParserRULE_sortSpecList) + p.EnterRule(localctx, 286, MDLParserRULE_sortSpecList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2855) + p.SetState(2926) p.SortSpec() } - p.SetState(2860) + p.SetState(2931) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38806,7 +39674,7 @@ func (p *MDLParser) SortSpecList() (localctx ISortSpecListContext) { for _la == MDLParserCOMMA { { - p.SetState(2856) + p.SetState(2927) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -38814,11 +39682,11 @@ func (p *MDLParser) SortSpecList() (localctx ISortSpecListContext) { } } { - p.SetState(2857) + p.SetState(2928) p.SortSpec() } - p.SetState(2862) + p.SetState(2933) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38921,19 +39789,19 @@ func (s *SortSpecContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SortSpec() (localctx ISortSpecContext) { localctx = NewSortSpecContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 284, MDLParserRULE_sortSpec) + p.EnterRule(localctx, 288, MDLParserRULE_sortSpec) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2863) + p.SetState(2934) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2865) + p.SetState(2936) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38942,7 +39810,7 @@ func (p *MDLParser) SortSpec() (localctx ISortSpecContext) { if _la == MDLParserASC || _la == MDLParserDESC { { - p.SetState(2864) + p.SetState(2935) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserASC || _la == MDLParserDESC) { @@ -39062,10 +39930,10 @@ func (s *AggregateListStatementContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) AggregateListStatement() (localctx IAggregateListStatementContext) { localctx = NewAggregateListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 286, MDLParserRULE_aggregateListStatement) + p.EnterRule(localctx, 290, MDLParserRULE_aggregateListStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2867) + p.SetState(2938) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -39073,7 +39941,7 @@ func (p *MDLParser) AggregateListStatement() (localctx IAggregateListStatementCo } } { - p.SetState(2868) + p.SetState(2939) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -39081,7 +39949,7 @@ func (p *MDLParser) AggregateListStatement() (localctx IAggregateListStatementCo } } { - p.SetState(2869) + p.SetState(2940) p.ListAggregateOperation() } @@ -39222,8 +40090,8 @@ func (s *ListAggregateOperationContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationContext) { localctx = NewListAggregateOperationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 288, MDLParserRULE_listAggregateOperation) - p.SetState(2895) + p.EnterRule(localctx, 292, MDLParserRULE_listAggregateOperation) + p.SetState(2966) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -39233,7 +40101,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo case MDLParserCOUNT: p.EnterOuterAlt(localctx, 1) { - p.SetState(2871) + p.SetState(2942) p.Match(MDLParserCOUNT) if p.HasError() { // Recognition error - abort rule @@ -39241,7 +40109,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2872) + p.SetState(2943) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -39249,7 +40117,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2873) + p.SetState(2944) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -39257,7 +40125,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2874) + p.SetState(2945) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -39268,7 +40136,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo case MDLParserSUM: p.EnterOuterAlt(localctx, 2) { - p.SetState(2875) + p.SetState(2946) p.Match(MDLParserSUM) if p.HasError() { // Recognition error - abort rule @@ -39276,7 +40144,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2876) + p.SetState(2947) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -39284,11 +40152,11 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2877) + p.SetState(2948) p.AttributePath() } { - p.SetState(2878) + p.SetState(2949) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -39299,7 +40167,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo case MDLParserAVERAGE: p.EnterOuterAlt(localctx, 3) { - p.SetState(2880) + p.SetState(2951) p.Match(MDLParserAVERAGE) if p.HasError() { // Recognition error - abort rule @@ -39307,7 +40175,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2881) + p.SetState(2952) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -39315,11 +40183,11 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2882) + p.SetState(2953) p.AttributePath() } { - p.SetState(2883) + p.SetState(2954) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -39330,7 +40198,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo case MDLParserMINIMUM: p.EnterOuterAlt(localctx, 4) { - p.SetState(2885) + p.SetState(2956) p.Match(MDLParserMINIMUM) if p.HasError() { // Recognition error - abort rule @@ -39338,7 +40206,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2886) + p.SetState(2957) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -39346,11 +40214,11 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2887) + p.SetState(2958) p.AttributePath() } { - p.SetState(2888) + p.SetState(2959) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -39361,7 +40229,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo case MDLParserMAXIMUM: p.EnterOuterAlt(localctx, 5) { - p.SetState(2890) + p.SetState(2961) p.Match(MDLParserMAXIMUM) if p.HasError() { // Recognition error - abort rule @@ -39369,7 +40237,7 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2891) + p.SetState(2962) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -39377,11 +40245,11 @@ func (p *MDLParser) ListAggregateOperation() (localctx IListAggregateOperationCo } } { - p.SetState(2892) + p.SetState(2963) p.AttributePath() } { - p.SetState(2893) + p.SetState(2964) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -39511,10 +40379,10 @@ func (s *CreateListStatementContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) CreateListStatement() (localctx ICreateListStatementContext) { localctx = NewCreateListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 290, MDLParserRULE_createListStatement) + p.EnterRule(localctx, 294, MDLParserRULE_createListStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2897) + p.SetState(2968) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -39522,7 +40390,7 @@ func (p *MDLParser) CreateListStatement() (localctx ICreateListStatementContext) } } { - p.SetState(2898) + p.SetState(2969) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -39530,7 +40398,7 @@ func (p *MDLParser) CreateListStatement() (localctx ICreateListStatementContext) } } { - p.SetState(2899) + p.SetState(2970) p.Match(MDLParserCREATE) if p.HasError() { // Recognition error - abort rule @@ -39538,7 +40406,7 @@ func (p *MDLParser) CreateListStatement() (localctx ICreateListStatementContext) } } { - p.SetState(2900) + p.SetState(2971) p.Match(MDLParserLIST_OF) if p.HasError() { // Recognition error - abort rule @@ -39546,7 +40414,7 @@ func (p *MDLParser) CreateListStatement() (localctx ICreateListStatementContext) } } { - p.SetState(2901) + p.SetState(2972) p.QualifiedName() } @@ -39650,10 +40518,10 @@ func (s *AddToListStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AddToListStatement() (localctx IAddToListStatementContext) { localctx = NewAddToListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 292, MDLParserRULE_addToListStatement) + p.EnterRule(localctx, 296, MDLParserRULE_addToListStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2903) + p.SetState(2974) p.Match(MDLParserADD) if p.HasError() { // Recognition error - abort rule @@ -39661,7 +40529,7 @@ func (p *MDLParser) AddToListStatement() (localctx IAddToListStatementContext) { } } { - p.SetState(2904) + p.SetState(2975) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -39669,7 +40537,7 @@ func (p *MDLParser) AddToListStatement() (localctx IAddToListStatementContext) { } } { - p.SetState(2905) + p.SetState(2976) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -39677,7 +40545,7 @@ func (p *MDLParser) AddToListStatement() (localctx IAddToListStatementContext) { } } { - p.SetState(2906) + p.SetState(2977) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -39785,10 +40653,10 @@ func (s *RemoveFromListStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) RemoveFromListStatement() (localctx IRemoveFromListStatementContext) { localctx = NewRemoveFromListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 294, MDLParserRULE_removeFromListStatement) + p.EnterRule(localctx, 298, MDLParserRULE_removeFromListStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2908) + p.SetState(2979) p.Match(MDLParserREMOVE) if p.HasError() { // Recognition error - abort rule @@ -39796,7 +40664,7 @@ func (p *MDLParser) RemoveFromListStatement() (localctx IRemoveFromListStatement } } { - p.SetState(2909) + p.SetState(2980) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -39804,7 +40672,7 @@ func (p *MDLParser) RemoveFromListStatement() (localctx IRemoveFromListStatement } } { - p.SetState(2910) + p.SetState(2981) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -39812,7 +40680,7 @@ func (p *MDLParser) RemoveFromListStatement() (localctx IRemoveFromListStatement } } { - p.SetState(2911) + p.SetState(2982) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -39953,15 +40821,15 @@ func (s *MemberAssignmentListContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) MemberAssignmentList() (localctx IMemberAssignmentListContext) { localctx = NewMemberAssignmentListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 296, MDLParserRULE_memberAssignmentList) + p.EnterRule(localctx, 300, MDLParserRULE_memberAssignmentList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2913) + p.SetState(2984) p.MemberAssignment() } - p.SetState(2918) + p.SetState(2989) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -39970,7 +40838,7 @@ func (p *MDLParser) MemberAssignmentList() (localctx IMemberAssignmentListContex for _la == MDLParserCOMMA { { - p.SetState(2914) + p.SetState(2985) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -39978,11 +40846,11 @@ func (p *MDLParser) MemberAssignmentList() (localctx IMemberAssignmentListContex } } { - p.SetState(2915) + p.SetState(2986) p.MemberAssignment() } - p.SetState(2920) + p.SetState(2991) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -40109,14 +40977,14 @@ func (s *MemberAssignmentContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MemberAssignment() (localctx IMemberAssignmentContext) { localctx = NewMemberAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 298, MDLParserRULE_memberAssignment) + p.EnterRule(localctx, 302, MDLParserRULE_memberAssignment) p.EnterOuterAlt(localctx, 1) { - p.SetState(2921) + p.SetState(2992) p.MemberAttributeName() } { - p.SetState(2922) + p.SetState(2993) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -40124,7 +40992,7 @@ func (p *MDLParser) MemberAssignment() (localctx IMemberAssignmentContext) { } } { - p.SetState(2923) + p.SetState(2994) p.Expression() } @@ -40252,25 +41120,25 @@ func (s *MemberAttributeNameContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) MemberAttributeName() (localctx IMemberAttributeNameContext) { localctx = NewMemberAttributeNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 300, MDLParserRULE_memberAttributeName) - p.SetState(2929) + p.EnterRule(localctx, 304, MDLParserRULE_memberAttributeName) + p.SetState(3000) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 294, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 297, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2925) + p.SetState(2996) p.QualifiedName() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2926) + p.SetState(2997) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -40281,7 +41149,7 @@ func (p *MDLParser) MemberAttributeName() (localctx IMemberAttributeNameContext) case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(2927) + p.SetState(2998) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -40292,7 +41160,7 @@ func (p *MDLParser) MemberAttributeName() (localctx IMemberAttributeNameContext) case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(2928) + p.SetState(2999) p.CommonNameKeyword() } @@ -40433,15 +41301,15 @@ func (s *ChangeListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ChangeList() (localctx IChangeListContext) { localctx = NewChangeListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 302, MDLParserRULE_changeList) + p.EnterRule(localctx, 306, MDLParserRULE_changeList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2931) + p.SetState(3002) p.ChangeItem() } - p.SetState(2936) + p.SetState(3007) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -40450,7 +41318,7 @@ func (p *MDLParser) ChangeList() (localctx IChangeListContext) { for _la == MDLParserCOMMA { { - p.SetState(2932) + p.SetState(3003) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -40458,11 +41326,11 @@ func (p *MDLParser) ChangeList() (localctx IChangeListContext) { } } { - p.SetState(2933) + p.SetState(3004) p.ChangeItem() } - p.SetState(2938) + p.SetState(3009) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -40577,10 +41445,10 @@ func (s *ChangeItemContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ChangeItem() (localctx IChangeItemContext) { localctx = NewChangeItemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 304, MDLParserRULE_changeItem) + p.EnterRule(localctx, 308, MDLParserRULE_changeItem) p.EnterOuterAlt(localctx, 1) { - p.SetState(2939) + p.SetState(3010) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -40588,7 +41456,7 @@ func (p *MDLParser) ChangeItem() (localctx IChangeItemContext) { } } { - p.SetState(2940) + p.SetState(3011) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -40596,7 +41464,7 @@ func (p *MDLParser) ChangeItem() (localctx IChangeItemContext) { } } { - p.SetState(2941) + p.SetState(3012) p.Expression() } @@ -40746,10 +41614,10 @@ func (s *CreatePageStatementContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) CreatePageStatement() (localctx ICreatePageStatementContext) { localctx = NewCreatePageStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 306, MDLParserRULE_createPageStatement) + p.EnterRule(localctx, 310, MDLParserRULE_createPageStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2943) + p.SetState(3014) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -40757,15 +41625,15 @@ func (p *MDLParser) CreatePageStatement() (localctx ICreatePageStatementContext) } } { - p.SetState(2944) + p.SetState(3015) p.QualifiedName() } { - p.SetState(2945) + p.SetState(3016) p.PageHeaderV3() } { - p.SetState(2946) + p.SetState(3017) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -40773,11 +41641,11 @@ func (p *MDLParser) CreatePageStatement() (localctx ICreatePageStatementContext) } } { - p.SetState(2947) + p.SetState(3018) p.PageBodyV3() } { - p.SetState(2948) + p.SetState(3019) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -40948,12 +41816,12 @@ func (s *CreateSnippetStatementContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) CreateSnippetStatement() (localctx ICreateSnippetStatementContext) { localctx = NewCreateSnippetStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 308, MDLParserRULE_createSnippetStatement) + p.EnterRule(localctx, 312, MDLParserRULE_createSnippetStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2950) + p.SetState(3021) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -40961,10 +41829,10 @@ func (p *MDLParser) CreateSnippetStatement() (localctx ICreateSnippetStatementCo } } { - p.SetState(2951) + p.SetState(3022) p.QualifiedName() } - p.SetState(2953) + p.SetState(3024) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -40973,12 +41841,12 @@ func (p *MDLParser) CreateSnippetStatement() (localctx ICreateSnippetStatementCo if _la == MDLParserLPAREN { { - p.SetState(2952) + p.SetState(3023) p.SnippetHeaderV3() } } - p.SetState(2956) + p.SetState(3027) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -40987,13 +41855,13 @@ func (p *MDLParser) CreateSnippetStatement() (localctx ICreateSnippetStatementCo if _la == MDLParserFOLDER { { - p.SetState(2955) + p.SetState(3026) p.SnippetOptions() } } { - p.SetState(2958) + p.SetState(3029) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -41001,11 +41869,11 @@ func (p *MDLParser) CreateSnippetStatement() (localctx ICreateSnippetStatementCo } } { - p.SetState(2959) + p.SetState(3030) p.PageBodyV3() } { - p.SetState(2960) + p.SetState(3031) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -41136,11 +42004,11 @@ func (s *SnippetOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SnippetOptions() (localctx ISnippetOptionsContext) { localctx = NewSnippetOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 310, MDLParserRULE_snippetOptions) + p.EnterRule(localctx, 314, MDLParserRULE_snippetOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2963) + p.SetState(3034) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -41149,11 +42017,11 @@ func (p *MDLParser) SnippetOptions() (localctx ISnippetOptionsContext) { for ok := true; ok; ok = _la == MDLParserFOLDER { { - p.SetState(2962) + p.SetState(3033) p.SnippetOption() } - p.SetState(2965) + p.SetState(3036) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -41251,10 +42119,10 @@ func (s *SnippetOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SnippetOption() (localctx ISnippetOptionContext) { localctx = NewSnippetOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 312, MDLParserRULE_snippetOption) + p.EnterRule(localctx, 316, MDLParserRULE_snippetOption) p.EnterOuterAlt(localctx, 1) { - p.SetState(2967) + p.SetState(3038) p.Match(MDLParserFOLDER) if p.HasError() { // Recognition error - abort rule @@ -41262,7 +42130,7 @@ func (p *MDLParser) SnippetOption() (localctx ISnippetOptionContext) { } } { - p.SetState(2968) + p.SetState(3039) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -41403,15 +42271,15 @@ func (s *PageParameterListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) PageParameterList() (localctx IPageParameterListContext) { localctx = NewPageParameterListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 314, MDLParserRULE_pageParameterList) + p.EnterRule(localctx, 318, MDLParserRULE_pageParameterList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2970) + p.SetState(3041) p.PageParameter() } - p.SetState(2975) + p.SetState(3046) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -41420,7 +42288,7 @@ func (p *MDLParser) PageParameterList() (localctx IPageParameterListContext) { for _la == MDLParserCOMMA { { - p.SetState(2971) + p.SetState(3042) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -41428,11 +42296,11 @@ func (p *MDLParser) PageParameterList() (localctx IPageParameterListContext) { } } { - p.SetState(2972) + p.SetState(3043) p.PageParameter() } - p.SetState(2977) + p.SetState(3048) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -41552,12 +42420,12 @@ func (s *PageParameterContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) PageParameter() (localctx IPageParameterContext) { localctx = NewPageParameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 316, MDLParserRULE_pageParameter) + p.EnterRule(localctx, 320, MDLParserRULE_pageParameter) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2978) + p.SetState(3049) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserVARIABLE || _la == MDLParserIDENTIFIER) { @@ -41568,7 +42436,7 @@ func (p *MDLParser) PageParameter() (localctx IPageParameterContext) { } } { - p.SetState(2979) + p.SetState(3050) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -41576,7 +42444,7 @@ func (p *MDLParser) PageParameter() (localctx IPageParameterContext) { } } { - p.SetState(2980) + p.SetState(3051) p.DataType() } @@ -41713,15 +42581,15 @@ func (s *SnippetParameterListContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) SnippetParameterList() (localctx ISnippetParameterListContext) { localctx = NewSnippetParameterListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 318, MDLParserRULE_snippetParameterList) + p.EnterRule(localctx, 322, MDLParserRULE_snippetParameterList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2982) + p.SetState(3053) p.SnippetParameter() } - p.SetState(2987) + p.SetState(3058) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -41730,7 +42598,7 @@ func (p *MDLParser) SnippetParameterList() (localctx ISnippetParameterListContex for _la == MDLParserCOMMA { { - p.SetState(2983) + p.SetState(3054) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -41738,11 +42606,11 @@ func (p *MDLParser) SnippetParameterList() (localctx ISnippetParameterListContex } } { - p.SetState(2984) + p.SetState(3055) p.SnippetParameter() } - p.SetState(2989) + p.SetState(3060) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -41862,12 +42730,12 @@ func (s *SnippetParameterContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SnippetParameter() (localctx ISnippetParameterContext) { localctx = NewSnippetParameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 320, MDLParserRULE_snippetParameter) + p.EnterRule(localctx, 324, MDLParserRULE_snippetParameter) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2990) + p.SetState(3061) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserVARIABLE || _la == MDLParserIDENTIFIER) { @@ -41878,7 +42746,7 @@ func (p *MDLParser) SnippetParameter() (localctx ISnippetParameterContext) { } } { - p.SetState(2991) + p.SetState(3062) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -41886,7 +42754,7 @@ func (p *MDLParser) SnippetParameter() (localctx ISnippetParameterContext) { } } { - p.SetState(2992) + p.SetState(3063) p.DataType() } @@ -42023,15 +42891,15 @@ func (s *VariableDeclarationListContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) VariableDeclarationList() (localctx IVariableDeclarationListContext) { localctx = NewVariableDeclarationListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 322, MDLParserRULE_variableDeclarationList) + p.EnterRule(localctx, 326, MDLParserRULE_variableDeclarationList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2994) + p.SetState(3065) p.VariableDeclaration() } - p.SetState(2999) + p.SetState(3070) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -42040,7 +42908,7 @@ func (p *MDLParser) VariableDeclarationList() (localctx IVariableDeclarationList for _la == MDLParserCOMMA { { - p.SetState(2995) + p.SetState(3066) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -42048,11 +42916,11 @@ func (p *MDLParser) VariableDeclarationList() (localctx IVariableDeclarationList } } { - p.SetState(2996) + p.SetState(3067) p.VariableDeclaration() } - p.SetState(3001) + p.SetState(3072) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -42177,10 +43045,10 @@ func (s *VariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) VariableDeclaration() (localctx IVariableDeclarationContext) { localctx = NewVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 324, MDLParserRULE_variableDeclaration) + p.EnterRule(localctx, 328, MDLParserRULE_variableDeclaration) p.EnterOuterAlt(localctx, 1) { - p.SetState(3002) + p.SetState(3073) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -42188,7 +43056,7 @@ func (p *MDLParser) VariableDeclaration() (localctx IVariableDeclarationContext) } } { - p.SetState(3003) + p.SetState(3074) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -42196,11 +43064,11 @@ func (p *MDLParser) VariableDeclaration() (localctx IVariableDeclarationContext) } } { - p.SetState(3004) + p.SetState(3075) p.DataType() } { - p.SetState(3005) + p.SetState(3076) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -42208,7 +43076,7 @@ func (p *MDLParser) VariableDeclaration() (localctx IVariableDeclarationContext) } } { - p.SetState(3006) + p.SetState(3077) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -42328,26 +43196,26 @@ func (s *SortColumnContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SortColumn() (localctx ISortColumnContext) { localctx = NewSortColumnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 326, MDLParserRULE_sortColumn) + p.EnterRule(localctx, 330, MDLParserRULE_sortColumn) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(3010) + p.SetState(3081) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 302, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 305, p.GetParserRuleContext()) { case 1: { - p.SetState(3008) + p.SetState(3079) p.QualifiedName() } case 2: { - p.SetState(3009) + p.SetState(3080) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -42358,7 +43226,7 @@ func (p *MDLParser) SortColumn() (localctx ISortColumnContext) { case antlr.ATNInvalidAltNumber: goto errorExit } - p.SetState(3013) + p.SetState(3084) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -42367,7 +43235,7 @@ func (p *MDLParser) SortColumn() (localctx ISortColumnContext) { if _la == MDLParserASC || _la == MDLParserDESC { { - p.SetState(3012) + p.SetState(3083) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserASC || _la == MDLParserDESC) { @@ -42487,10 +43355,10 @@ func (s *XpathConstraintContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathConstraint() (localctx IXpathConstraintContext) { localctx = NewXpathConstraintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 328, MDLParserRULE_xpathConstraint) + p.EnterRule(localctx, 332, MDLParserRULE_xpathConstraint) p.EnterOuterAlt(localctx, 1) { - p.SetState(3015) + p.SetState(3086) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -42498,11 +43366,11 @@ func (p *MDLParser) XpathConstraint() (localctx IXpathConstraintContext) { } } { - p.SetState(3016) + p.SetState(3087) p.XpathExpr() } { - p.SetState(3017) + p.SetState(3088) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -42600,12 +43468,12 @@ func (s *AndOrXpathContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AndOrXpath() (localctx IAndOrXpathContext) { localctx = NewAndOrXpathContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 330, MDLParserRULE_andOrXpath) + p.EnterRule(localctx, 334, MDLParserRULE_andOrXpath) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3019) + p.SetState(3090) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserAND || _la == MDLParserOR) { @@ -42749,15 +43617,15 @@ func (s *XpathExprContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathExpr() (localctx IXpathExprContext) { localctx = NewXpathExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 332, MDLParserRULE_xpathExpr) + p.EnterRule(localctx, 336, MDLParserRULE_xpathExpr) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3021) + p.SetState(3092) p.XpathAndExpr() } - p.SetState(3026) + p.SetState(3097) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -42766,7 +43634,7 @@ func (p *MDLParser) XpathExpr() (localctx IXpathExprContext) { for _la == MDLParserOR { { - p.SetState(3022) + p.SetState(3093) p.Match(MDLParserOR) if p.HasError() { // Recognition error - abort rule @@ -42774,11 +43642,11 @@ func (p *MDLParser) XpathExpr() (localctx IXpathExprContext) { } } { - p.SetState(3023) + p.SetState(3094) p.XpathAndExpr() } - p.SetState(3028) + p.SetState(3099) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -42919,15 +43787,15 @@ func (s *XpathAndExprContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathAndExpr() (localctx IXpathAndExprContext) { localctx = NewXpathAndExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 334, MDLParserRULE_xpathAndExpr) + p.EnterRule(localctx, 338, MDLParserRULE_xpathAndExpr) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3029) + p.SetState(3100) p.XpathNotExpr() } - p.SetState(3034) + p.SetState(3105) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -42936,7 +43804,7 @@ func (p *MDLParser) XpathAndExpr() (localctx IXpathAndExprContext) { for _la == MDLParserAND { { - p.SetState(3030) + p.SetState(3101) p.Match(MDLParserAND) if p.HasError() { // Recognition error - abort rule @@ -42944,11 +43812,11 @@ func (p *MDLParser) XpathAndExpr() (localctx IXpathAndExprContext) { } } { - p.SetState(3031) + p.SetState(3102) p.XpathNotExpr() } - p.SetState(3036) + p.SetState(3107) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -43075,18 +43943,18 @@ func (s *XpathNotExprContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathNotExpr() (localctx IXpathNotExprContext) { localctx = NewXpathNotExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 336, MDLParserRULE_xpathNotExpr) - p.SetState(3040) + p.EnterRule(localctx, 340, MDLParserRULE_xpathNotExpr) + p.SetState(3111) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 306, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 309, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(3037) + p.SetState(3108) p.Match(MDLParserNOT) if p.HasError() { // Recognition error - abort rule @@ -43094,14 +43962,14 @@ func (p *MDLParser) XpathNotExpr() (localctx IXpathNotExprContext) { } } { - p.SetState(3038) + p.SetState(3109) p.XpathNotExpr() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(3039) + p.SetState(3110) p.XpathComparisonExpr() } @@ -43249,28 +44117,28 @@ func (s *XpathComparisonExprContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) XpathComparisonExpr() (localctx IXpathComparisonExprContext) { localctx = NewXpathComparisonExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 338, MDLParserRULE_xpathComparisonExpr) + p.EnterRule(localctx, 342, MDLParserRULE_xpathComparisonExpr) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3042) + p.SetState(3113) p.XpathValueExpr() } - p.SetState(3046) + p.SetState(3117) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if (int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&63) != 0 { + if (int64((_la-469)) & ^0x3f) == 0 && ((int64(1)<<(_la-469))&63) != 0 { { - p.SetState(3043) + p.SetState(3114) p.ComparisonOperator() } { - p.SetState(3044) + p.SetState(3115) p.XpathValueExpr() } @@ -43417,32 +44285,32 @@ func (s *XpathValueExprContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathValueExpr() (localctx IXpathValueExprContext) { localctx = NewXpathValueExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 340, MDLParserRULE_xpathValueExpr) - p.SetState(3054) + p.EnterRule(localctx, 344, MDLParserRULE_xpathValueExpr) + p.SetState(3125) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 308, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 311, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(3048) + p.SetState(3119) p.XpathFunctionCall() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(3049) + p.SetState(3120) p.XpathPath() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(3050) + p.SetState(3121) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -43450,11 +44318,11 @@ func (p *MDLParser) XpathValueExpr() (localctx IXpathValueExprContext) { } } { - p.SetState(3051) + p.SetState(3122) p.XpathExpr() } { - p.SetState(3052) + p.SetState(3123) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -43599,15 +44467,15 @@ func (s *XpathPathContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathPath() (localctx IXpathPathContext) { localctx = NewXpathPathContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 342, MDLParserRULE_xpathPath) + p.EnterRule(localctx, 346, MDLParserRULE_xpathPath) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3056) + p.SetState(3127) p.XpathStep() } - p.SetState(3061) + p.SetState(3132) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -43616,7 +44484,7 @@ func (p *MDLParser) XpathPath() (localctx IXpathPathContext) { for _la == MDLParserSLASH { { - p.SetState(3057) + p.SetState(3128) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule @@ -43624,11 +44492,11 @@ func (p *MDLParser) XpathPath() (localctx IXpathPathContext) { } } { - p.SetState(3058) + p.SetState(3129) p.XpathStep() } - p.SetState(3063) + p.SetState(3134) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -43760,15 +44628,15 @@ func (s *XpathStepContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathStep() (localctx IXpathStepContext) { localctx = NewXpathStepContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 344, MDLParserRULE_xpathStep) + p.EnterRule(localctx, 348, MDLParserRULE_xpathStep) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3064) + p.SetState(3135) p.XpathStepValue() } - p.SetState(3069) + p.SetState(3140) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -43777,7 +44645,7 @@ func (p *MDLParser) XpathStep() (localctx IXpathStepContext) { if _la == MDLParserLBRACKET { { - p.SetState(3065) + p.SetState(3136) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -43785,11 +44653,11 @@ func (p *MDLParser) XpathStep() (localctx IXpathStepContext) { } } { - p.SetState(3066) + p.SetState(3137) p.XpathExpr() } { - p.SetState(3067) + p.SetState(3138) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -43916,25 +44784,25 @@ func (s *XpathStepValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathStepValue() (localctx IXpathStepValueContext) { localctx = NewXpathStepValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 346, MDLParserRULE_xpathStepValue) - p.SetState(3076) + p.EnterRule(localctx, 350, MDLParserRULE_xpathStepValue) + p.SetState(3147) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { - case MDLParserWS, MDLParserDOC_COMMENT, MDLParserBLOCK_COMMENT, MDLParserLINE_COMMENT, MDLParserIS_NOT_NULL, MDLParserIS_NULL, MDLParserNOT_NULL, MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserSORT_BY, MDLParserNON_PERSISTENT, MDLParserREFERENCE_SET, MDLParserLIST_OF, MDLParserDELETE_AND_REFERENCES, MDLParserDELETE_BUT_KEEP_REFERENCES, MDLParserDELETE_IF_NO_REFERENCES, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserMODIFY, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserNANOFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserNOTEBOOK, MDLParserCONSTANT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserGENERALIZATION, MDLParserEXTENDS, MDLParserADD, MDLParserSET, MDLParserPOSITION, MDLParserDOCUMENTATION, MDLParserSTORAGE, MDLParserTABLE, MDLParserDELETE_BEHAVIOR, MDLParserCASCADE, MDLParserPREVENT, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserRUNTIME, MDLParserBRANCH, MDLParserTOKEN, MDLParserHOST, MDLParserPORT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserINTROSPECT, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserRETURNS, MDLParserRETURNING, MDLParserCASE, MDLParserWHEN, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserFULL, MDLParserCROSS, MDLParserON, MDLParserASC, MDLParserDESC, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserROLLBACK, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserELSEIF, MDLParserCONTINUE, MDLParserBREAK, MDLParserRETURN, MDLParserTHROW, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserNODE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserREMOVE, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserTRACE, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserPLACEHOLDER, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserCONTAINER, MDLParserROW, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserSTATICTEXT, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserDROPDOWN, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserREFERENCESELECTOR, MDLParserINPUTREFERENCESETSELECTOR, MDLParserFILEINPUT, MDLParserIMAGEINPUT, MDLParserCUSTOMWIDGET, MDLParserTEXTFILTER, MDLParserNUMBERFILTER, MDLParserDROPDOWNFILTER, MDLParserDATEFILTER, MDLParserFILTER, MDLParserWIDGET, MDLParserWIDGETS, MDLParserCAPTION, MDLParserICON, MDLParserTOOLTIP, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserRENDERMODE, MDLParserBINDS, MDLParserATTR, MDLParserCONTENTPARAMS, MDLParserCAPTIONPARAMS, MDLParserPARAMS, MDLParserVARIABLES_KW, MDLParserDESKTOPWIDTH, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserAUTOFILL, MDLParserURL, MDLParserFOLDER, MDLParserPASSING, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserREADONLY, MDLParserATTRIBUTES, MDLParserFILTERTYPE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserSAVECHANGES, MDLParserSAVE_CHANGES, MDLParserCANCEL_CHANGES, MDLParserCLOSE_PAGE, MDLParserSHOW_PAGE, MDLParserDELETE_ACTION, MDLParserDELETE_OBJECT, MDLParserCREATE_OBJECT, MDLParserCALL_MICROFLOW, MDLParserCALL_NANOFLOW, MDLParserOPEN_LINK, MDLParserSIGN_OUT, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserWARNING_STYLE, MDLParserINFO_STYLE, MDLParserTEMPLATE, MDLParserONCLICK, MDLParserONCHANGE, MDLParserTABINDEX, MDLParserH1, MDLParserH2, MDLParserH3, MDLParserH4, MDLParserH5, MDLParserH6, MDLParserPARAGRAPH, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserHASHEDSTRING_TYPE, MDLParserCURRENCY_TYPE, MDLParserFLOAT_TYPE, MDLParserSTRINGTEMPLATE_TYPE, MDLParserENUM_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCOALESCE, MDLParserCAST, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserMATCH, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRAISE, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserXPATH, MDLParserCONSTRAINT, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserREQUEST, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserGET, MDLParserPOST, MDLParserPUT, MDLParserPATCH, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserEXPOSED, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserCONNECTIONS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserRULES, MDLParserTEXT, MDLParserSARIF, MDLParserMESSAGE, MDLParserCOMMENT, MDLParserCATALOG, MDLParserFORCE, MDLParserBACKGROUND, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserATTRIBUTE_NAME, MDLParserFORMAT, MDLParserSQL, MDLParserWITHOUT, MDLParserDRY, MDLParserRUN, MDLParserWIDGETTYPE, MDLParserV3, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserSTAR, MDLParserPERCENT, MDLParserMOD, MDLParserDIV, MDLParserLBRACE, MDLParserRBRACE, MDLParserCOLON, MDLParserAT, MDLParserPIPE, MDLParserDOUBLE_COLON, MDLParserARROW, MDLParserQUESTION, MDLParserHASH, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: + case MDLParserWS, MDLParserDOC_COMMENT, MDLParserBLOCK_COMMENT, MDLParserLINE_COMMENT, MDLParserIS_NOT_NULL, MDLParserIS_NULL, MDLParserNOT_NULL, MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserSORT_BY, MDLParserNON_PERSISTENT, MDLParserREFERENCE_SET, MDLParserLIST_OF, MDLParserDELETE_AND_REFERENCES, MDLParserDELETE_BUT_KEEP_REFERENCES, MDLParserDELETE_IF_NO_REFERENCES, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserMODIFY, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserNANOFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserNOTEBOOK, MDLParserCONSTANT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserGENERALIZATION, MDLParserEXTENDS, MDLParserADD, MDLParserSET, MDLParserPOSITION, MDLParserDOCUMENTATION, MDLParserSTORAGE, MDLParserTABLE, MDLParserDELETE_BEHAVIOR, MDLParserCASCADE, MDLParserPREVENT, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserRUNTIME, MDLParserBRANCH, MDLParserTOKEN, MDLParserHOST, MDLParserPORT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserINTROSPECT, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserRETURNS, MDLParserRETURNING, MDLParserCASE, MDLParserWHEN, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserFULL, MDLParserCROSS, MDLParserON, MDLParserASC, MDLParserDESC, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserROLLBACK, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserELSEIF, MDLParserCONTINUE, MDLParserBREAK, MDLParserRETURN, MDLParserTHROW, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserNODE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserREMOVE, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserTRACE, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserPLACEHOLDER, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserCONTAINER, MDLParserROW, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserSTATICTEXT, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserDROPDOWN, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserREFERENCESELECTOR, MDLParserINPUTREFERENCESETSELECTOR, MDLParserFILEINPUT, MDLParserIMAGEINPUT, MDLParserCUSTOMWIDGET, MDLParserTEXTFILTER, MDLParserNUMBERFILTER, MDLParserDROPDOWNFILTER, MDLParserDATEFILTER, MDLParserFILTER, MDLParserWIDGET, MDLParserWIDGETS, MDLParserCAPTION, MDLParserICON, MDLParserTOOLTIP, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserRENDERMODE, MDLParserBINDS, MDLParserATTR, MDLParserCONTENTPARAMS, MDLParserCAPTIONPARAMS, MDLParserPARAMS, MDLParserVARIABLES_KW, MDLParserDESKTOPWIDTH, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserAUTOFILL, MDLParserURL, MDLParserFOLDER, MDLParserPASSING, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserREADONLY, MDLParserATTRIBUTES, MDLParserFILTERTYPE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserSAVECHANGES, MDLParserSAVE_CHANGES, MDLParserCANCEL_CHANGES, MDLParserCLOSE_PAGE, MDLParserSHOW_PAGE, MDLParserDELETE_ACTION, MDLParserDELETE_OBJECT, MDLParserCREATE_OBJECT, MDLParserCALL_MICROFLOW, MDLParserCALL_NANOFLOW, MDLParserOPEN_LINK, MDLParserSIGN_OUT, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserWARNING_STYLE, MDLParserINFO_STYLE, MDLParserTEMPLATE, MDLParserONCLICK, MDLParserONCHANGE, MDLParserTABINDEX, MDLParserH1, MDLParserH2, MDLParserH3, MDLParserH4, MDLParserH5, MDLParserH6, MDLParserPARAGRAPH, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserHASHEDSTRING_TYPE, MDLParserCURRENCY_TYPE, MDLParserFLOAT_TYPE, MDLParserSTRINGTEMPLATE_TYPE, MDLParserENUM_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCOALESCE, MDLParserCAST, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserMATCH, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRAISE, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserXPATH, MDLParserCONSTRAINT, MDLParserCALCULATED, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserREQUEST, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserGET, MDLParserPOST, MDLParserPUT, MDLParserPATCH, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserEXPOSED, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserCONNECTIONS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserRULES, MDLParserTEXT, MDLParserSARIF, MDLParserMESSAGE, MDLParserCOMMENT, MDLParserCATALOG, MDLParserFORCE, MDLParserBACKGROUND, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserATTRIBUTE_NAME, MDLParserFORMAT, MDLParserSQL, MDLParserWITHOUT, MDLParserDRY, MDLParserRUN, MDLParserWIDGETTYPE, MDLParserV3, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserANNOTATION, MDLParserBOUNDARY, MDLParserINTERRUPTING, MDLParserNON, MDLParserMULTI, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserDISPLAY, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserSTAR, MDLParserPERCENT, MDLParserMOD, MDLParserDIV, MDLParserLBRACE, MDLParserRBRACE, MDLParserCOLON, MDLParserAT, MDLParserPIPE, MDLParserDOUBLE_COLON, MDLParserARROW, MDLParserQUESTION, MDLParserHASH, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(3071) + p.SetState(3142) p.XpathQualifiedName() } case MDLParserVARIABLE: p.EnterOuterAlt(localctx, 2) { - p.SetState(3072) + p.SetState(3143) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -43945,7 +44813,7 @@ func (p *MDLParser) XpathStepValue() (localctx IXpathStepValueContext) { case MDLParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 3) { - p.SetState(3073) + p.SetState(3144) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -43956,7 +44824,7 @@ func (p *MDLParser) XpathStepValue() (localctx IXpathStepValueContext) { case MDLParserNUMBER_LITERAL: p.EnterOuterAlt(localctx, 4) { - p.SetState(3074) + p.SetState(3145) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -43967,7 +44835,7 @@ func (p *MDLParser) XpathStepValue() (localctx IXpathStepValueContext) { case MDLParserMENDIX_TOKEN: p.EnterOuterAlt(localctx, 5) { - p.SetState(3075) + p.SetState(3146) p.Match(MDLParserMENDIX_TOKEN) if p.HasError() { // Recognition error - abort rule @@ -44113,15 +44981,15 @@ func (s *XpathQualifiedNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathQualifiedName() (localctx IXpathQualifiedNameContext) { localctx = NewXpathQualifiedNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 348, MDLParserRULE_xpathQualifiedName) + p.EnterRule(localctx, 352, MDLParserRULE_xpathQualifiedName) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3078) + p.SetState(3149) p.XpathWord() } - p.SetState(3083) + p.SetState(3154) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -44130,7 +44998,7 @@ func (p *MDLParser) XpathQualifiedName() (localctx IXpathQualifiedNameContext) { for _la == MDLParserDOT { { - p.SetState(3079) + p.SetState(3150) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule @@ -44138,11 +45006,11 @@ func (p *MDLParser) XpathQualifiedName() (localctx IXpathQualifiedNameContext) { } } { - p.SetState(3080) + p.SetState(3151) p.XpathWord() } - p.SetState(3085) + p.SetState(3156) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -44340,15 +45208,15 @@ func (s *XpathWordContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathWord() (localctx IXpathWordContext) { localctx = NewXpathWordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 350, MDLParserRULE_xpathWord) + p.EnterRule(localctx, 354, MDLParserRULE_xpathWord) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3086) + p.SetState(3157) _la = p.GetTokenStream().LA(1) - if _la <= 0 || ((int64((_la-280)) & ^0x3f) == 0 && ((int64(1)<<(_la-280))&7) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&16646398527) != 0) { + if _la <= 0 || ((int64((_la-280)) & ^0x3f) == 0 && ((int64(1)<<(_la-280))&7) != 0) || ((int64((_la-469)) & ^0x3f) == 0 && ((int64(1)<<(_la-469))&16646398527) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -44516,35 +45384,35 @@ func (s *XpathFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathFunctionCall() (localctx IXpathFunctionCallContext) { localctx = NewXpathFunctionCallContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 352, MDLParserRULE_xpathFunctionCall) + p.EnterRule(localctx, 356, MDLParserRULE_xpathFunctionCall) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3088) + p.SetState(3159) p.XpathFunctionName() } { - p.SetState(3089) + p.SetState(3160) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3098) + p.SetState(3169) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-2) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-1) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-50331649) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-1) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-1) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2113877111) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-2) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-1) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-50331649) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-1) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-1) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&283719783111720959) != 0) { { - p.SetState(3090) + p.SetState(3161) p.XpathExpr() } - p.SetState(3095) + p.SetState(3166) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -44553,7 +45421,7 @@ func (p *MDLParser) XpathFunctionCall() (localctx IXpathFunctionCallContext) { for _la == MDLParserCOMMA { { - p.SetState(3091) + p.SetState(3162) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -44561,11 +45429,11 @@ func (p *MDLParser) XpathFunctionCall() (localctx IXpathFunctionCallContext) { } } { - p.SetState(3092) + p.SetState(3163) p.XpathExpr() } - p.SetState(3097) + p.SetState(3168) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -44575,7 +45443,7 @@ func (p *MDLParser) XpathFunctionCall() (localctx IXpathFunctionCallContext) { } { - p.SetState(3100) + p.SetState(3171) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -44693,12 +45561,12 @@ func (s *XpathFunctionNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) XpathFunctionName() (localctx IXpathFunctionNameContext) { localctx = NewXpathFunctionNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 354, MDLParserRULE_xpathFunctionName) + p.EnterRule(localctx, 358, MDLParserRULE_xpathFunctionName) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3102) + p.SetState(3173) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserCONTAINS || ((int64((_la-282)) & ^0x3f) == 0 && ((int64(1)<<(_la-282))&1537) != 0) || _la == MDLParserIDENTIFIER || _la == MDLParserHYPHENATED_ID) { @@ -44852,12 +45720,12 @@ func (s *PageHeaderV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) PageHeaderV3() (localctx IPageHeaderV3Context) { localctx = NewPageHeaderV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 356, MDLParserRULE_pageHeaderV3) + p.EnterRule(localctx, 360, MDLParserRULE_pageHeaderV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3104) + p.SetState(3175) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -44865,10 +45733,10 @@ func (p *MDLParser) PageHeaderV3() (localctx IPageHeaderV3Context) { } } { - p.SetState(3105) + p.SetState(3176) p.PageHeaderPropertyV3() } - p.SetState(3110) + p.SetState(3181) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -44877,7 +45745,7 @@ func (p *MDLParser) PageHeaderV3() (localctx IPageHeaderV3Context) { for _la == MDLParserCOMMA { { - p.SetState(3106) + p.SetState(3177) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -44885,11 +45753,11 @@ func (p *MDLParser) PageHeaderV3() (localctx IPageHeaderV3Context) { } } { - p.SetState(3107) + p.SetState(3178) p.PageHeaderPropertyV3() } - p.SetState(3112) + p.SetState(3183) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -44897,7 +45765,7 @@ func (p *MDLParser) PageHeaderV3() (localctx IPageHeaderV3Context) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3113) + p.SetState(3184) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -45086,8 +45954,8 @@ func (s *PageHeaderPropertyV3Context) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Context) { localctx = NewPageHeaderPropertyV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 358, MDLParserRULE_pageHeaderPropertyV3) - p.SetState(3142) + p.EnterRule(localctx, 362, MDLParserRULE_pageHeaderPropertyV3) + p.SetState(3213) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -45097,7 +45965,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex case MDLParserPARAMS: p.EnterOuterAlt(localctx, 1) { - p.SetState(3115) + p.SetState(3186) p.Match(MDLParserPARAMS) if p.HasError() { // Recognition error - abort rule @@ -45105,7 +45973,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3116) + p.SetState(3187) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45113,7 +45981,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3117) + p.SetState(3188) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -45121,11 +45989,11 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3118) + p.SetState(3189) p.PageParameterList() } { - p.SetState(3119) + p.SetState(3190) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -45136,7 +46004,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex case MDLParserVARIABLES_KW: p.EnterOuterAlt(localctx, 2) { - p.SetState(3121) + p.SetState(3192) p.Match(MDLParserVARIABLES_KW) if p.HasError() { // Recognition error - abort rule @@ -45144,7 +46012,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3122) + p.SetState(3193) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45152,7 +46020,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3123) + p.SetState(3194) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -45160,11 +46028,11 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3124) + p.SetState(3195) p.VariableDeclarationList() } { - p.SetState(3125) + p.SetState(3196) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -45175,7 +46043,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex case MDLParserTITLE: p.EnterOuterAlt(localctx, 3) { - p.SetState(3127) + p.SetState(3198) p.Match(MDLParserTITLE) if p.HasError() { // Recognition error - abort rule @@ -45183,7 +46051,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3128) + p.SetState(3199) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45191,7 +46059,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3129) + p.SetState(3200) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -45202,7 +46070,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex case MDLParserLAYOUT: p.EnterOuterAlt(localctx, 4) { - p.SetState(3130) + p.SetState(3201) p.Match(MDLParserLAYOUT) if p.HasError() { // Recognition error - abort rule @@ -45210,29 +46078,29 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3131) + p.SetState(3202) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3134) + p.SetState(3205) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: { - p.SetState(3132) + p.SetState(3203) p.QualifiedName() } case MDLParserSTRING_LITERAL: { - p.SetState(3133) + p.SetState(3204) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -45248,7 +46116,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex case MDLParserURL: p.EnterOuterAlt(localctx, 5) { - p.SetState(3136) + p.SetState(3207) p.Match(MDLParserURL) if p.HasError() { // Recognition error - abort rule @@ -45256,7 +46124,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3137) + p.SetState(3208) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45264,7 +46132,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3138) + p.SetState(3209) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -45275,7 +46143,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex case MDLParserFOLDER: p.EnterOuterAlt(localctx, 6) { - p.SetState(3139) + p.SetState(3210) p.Match(MDLParserFOLDER) if p.HasError() { // Recognition error - abort rule @@ -45283,7 +46151,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3140) + p.SetState(3211) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45291,7 +46159,7 @@ func (p *MDLParser) PageHeaderPropertyV3() (localctx IPageHeaderPropertyV3Contex } } { - p.SetState(3141) + p.SetState(3212) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -45447,12 +46315,12 @@ func (s *SnippetHeaderV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SnippetHeaderV3() (localctx ISnippetHeaderV3Context) { localctx = NewSnippetHeaderV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 360, MDLParserRULE_snippetHeaderV3) + p.EnterRule(localctx, 364, MDLParserRULE_snippetHeaderV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3144) + p.SetState(3215) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -45460,10 +46328,10 @@ func (p *MDLParser) SnippetHeaderV3() (localctx ISnippetHeaderV3Context) { } } { - p.SetState(3145) + p.SetState(3216) p.SnippetHeaderPropertyV3() } - p.SetState(3150) + p.SetState(3221) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -45472,7 +46340,7 @@ func (p *MDLParser) SnippetHeaderV3() (localctx ISnippetHeaderV3Context) { for _la == MDLParserCOMMA { { - p.SetState(3146) + p.SetState(3217) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -45480,11 +46348,11 @@ func (p *MDLParser) SnippetHeaderV3() (localctx ISnippetHeaderV3Context) { } } { - p.SetState(3147) + p.SetState(3218) p.SnippetHeaderPropertyV3() } - p.SetState(3152) + p.SetState(3223) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -45492,7 +46360,7 @@ func (p *MDLParser) SnippetHeaderV3() (localctx ISnippetHeaderV3Context) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3153) + p.SetState(3224) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -45649,8 +46517,8 @@ func (s *SnippetHeaderPropertyV3Context) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3Context) { localctx = NewSnippetHeaderPropertyV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 362, MDLParserRULE_snippetHeaderPropertyV3) - p.SetState(3170) + p.EnterRule(localctx, 366, MDLParserRULE_snippetHeaderPropertyV3) + p.SetState(3241) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -45660,7 +46528,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 case MDLParserPARAMS: p.EnterOuterAlt(localctx, 1) { - p.SetState(3155) + p.SetState(3226) p.Match(MDLParserPARAMS) if p.HasError() { // Recognition error - abort rule @@ -45668,7 +46536,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3156) + p.SetState(3227) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45676,7 +46544,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3157) + p.SetState(3228) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -45684,11 +46552,11 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3158) + p.SetState(3229) p.SnippetParameterList() } { - p.SetState(3159) + p.SetState(3230) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -45699,7 +46567,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 case MDLParserVARIABLES_KW: p.EnterOuterAlt(localctx, 2) { - p.SetState(3161) + p.SetState(3232) p.Match(MDLParserVARIABLES_KW) if p.HasError() { // Recognition error - abort rule @@ -45707,7 +46575,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3162) + p.SetState(3233) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45715,7 +46583,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3163) + p.SetState(3234) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -45723,11 +46591,11 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3164) + p.SetState(3235) p.VariableDeclarationList() } { - p.SetState(3165) + p.SetState(3236) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -45738,7 +46606,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 case MDLParserFOLDER: p.EnterOuterAlt(localctx, 3) { - p.SetState(3167) + p.SetState(3238) p.Match(MDLParserFOLDER) if p.HasError() { // Recognition error - abort rule @@ -45746,7 +46614,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3168) + p.SetState(3239) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -45754,7 +46622,7 @@ func (p *MDLParser) SnippetHeaderPropertyV3() (localctx ISnippetHeaderPropertyV3 } } { - p.SetState(3169) + p.SetState(3240) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -45933,11 +46801,11 @@ func (s *PageBodyV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) PageBodyV3() (localctx IPageBodyV3Context) { localctx = NewPageBodyV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 364, MDLParserRULE_pageBodyV3) + p.EnterRule(localctx, 368, MDLParserRULE_pageBodyV3) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(3176) + p.SetState(3247) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -45945,7 +46813,7 @@ func (p *MDLParser) PageBodyV3() (localctx IPageBodyV3Context) { _la = p.GetTokenStream().LA(1) for _la == MDLParserCOLUMN || _la == MDLParserUSE || ((int64((_la-146)) & ^0x3f) == 0 && ((int64(1)<<(_la-146))&211377350996991) != 0) || ((int64((_la-222)) & ^0x3f) == 0 && ((int64(1)<<(_la-222))&16777247) != 0) { - p.SetState(3174) + p.SetState(3245) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -45954,13 +46822,13 @@ func (p *MDLParser) PageBodyV3() (localctx IPageBodyV3Context) { switch p.GetTokenStream().LA(1) { case MDLParserCOLUMN, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserCONTAINER, MDLParserROW, MDLParserITEM, MDLParserCONTROLBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserSTATICTEXT, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserDROPDOWN, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserREFERENCESELECTOR, MDLParserCUSTOMWIDGET, MDLParserTEXTFILTER, MDLParserNUMBERFILTER, MDLParserDROPDOWNFILTER, MDLParserDATEFILTER, MDLParserFILTER, MDLParserFOOTER, MDLParserHEADER, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserTEMPLATE: { - p.SetState(3172) + p.SetState(3243) p.WidgetV3() } case MDLParserUSE: { - p.SetState(3173) + p.SetState(3244) p.UseFragmentRef() } @@ -45969,7 +46837,7 @@ func (p *MDLParser) PageBodyV3() (localctx IPageBodyV3Context) { goto errorExit } - p.SetState(3178) + p.SetState(3249) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -46115,12 +46983,12 @@ func (s *UseFragmentRefContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) UseFragmentRef() (localctx IUseFragmentRefContext) { localctx = NewUseFragmentRefContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 366, MDLParserRULE_useFragmentRef) + p.EnterRule(localctx, 370, MDLParserRULE_useFragmentRef) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3179) + p.SetState(3250) p.Match(MDLParserUSE) if p.HasError() { // Recognition error - abort rule @@ -46128,7 +46996,7 @@ func (p *MDLParser) UseFragmentRef() (localctx IUseFragmentRefContext) { } } { - p.SetState(3180) + p.SetState(3251) p.Match(MDLParserFRAGMENT) if p.HasError() { // Recognition error - abort rule @@ -46136,10 +47004,10 @@ func (p *MDLParser) UseFragmentRef() (localctx IUseFragmentRefContext) { } } { - p.SetState(3181) + p.SetState(3252) p.IdentifierOrKeyword() } - p.SetState(3184) + p.SetState(3255) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -46148,7 +47016,7 @@ func (p *MDLParser) UseFragmentRef() (localctx IUseFragmentRefContext) { if _la == MDLParserAS { { - p.SetState(3182) + p.SetState(3253) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -46156,7 +47024,7 @@ func (p *MDLParser) UseFragmentRef() (localctx IUseFragmentRefContext) { } } { - p.SetState(3183) + p.SetState(3254) p.IdentifierOrKeyword() } @@ -46298,23 +47166,23 @@ func (s *WidgetV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WidgetV3() (localctx IWidgetV3Context) { localctx = NewWidgetV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 368, MDLParserRULE_widgetV3) + p.EnterRule(localctx, 372, MDLParserRULE_widgetV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3186) + p.SetState(3257) p.WidgetTypeV3() } { - p.SetState(3187) + p.SetState(3258) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3189) + p.SetState(3260) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -46323,12 +47191,12 @@ func (p *MDLParser) WidgetV3() (localctx IWidgetV3Context) { if _la == MDLParserLPAREN { { - p.SetState(3188) + p.SetState(3259) p.WidgetPropertiesV3() } } - p.SetState(3192) + p.SetState(3263) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -46337,7 +47205,7 @@ func (p *MDLParser) WidgetV3() (localctx IWidgetV3Context) { if _la == MDLParserLBRACE { { - p.SetState(3191) + p.SetState(3262) p.WidgetBodyV3() } @@ -46618,12 +47486,12 @@ func (s *WidgetTypeV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WidgetTypeV3() (localctx IWidgetTypeV3Context) { localctx = NewWidgetTypeV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 370, MDLParserRULE_widgetTypeV3) + p.EnterRule(localctx, 374, MDLParserRULE_widgetTypeV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3194) + p.SetState(3265) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserCOLUMN || ((int64((_la-146)) & ^0x3f) == 0 && ((int64(1)<<(_la-146))&211377350996991) != 0) || ((int64((_la-222)) & ^0x3f) == 0 && ((int64(1)<<(_la-222))&16777247) != 0)) { @@ -46777,12 +47645,12 @@ func (s *WidgetPropertiesV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WidgetPropertiesV3() (localctx IWidgetPropertiesV3Context) { localctx = NewWidgetPropertiesV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 372, MDLParserRULE_widgetPropertiesV3) + p.EnterRule(localctx, 376, MDLParserRULE_widgetPropertiesV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3196) + p.SetState(3267) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -46790,10 +47658,10 @@ func (p *MDLParser) WidgetPropertiesV3() (localctx IWidgetPropertiesV3Context) { } } { - p.SetState(3197) + p.SetState(3268) p.WidgetPropertyV3() } - p.SetState(3202) + p.SetState(3273) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -46802,7 +47670,7 @@ func (p *MDLParser) WidgetPropertiesV3() (localctx IWidgetPropertiesV3Context) { for _la == MDLParserCOMMA { { - p.SetState(3198) + p.SetState(3269) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -46810,11 +47678,11 @@ func (p *MDLParser) WidgetPropertiesV3() (localctx IWidgetPropertiesV3Context) { } } { - p.SetState(3199) + p.SetState(3270) p.WidgetPropertyV3() } - p.SetState(3204) + p.SetState(3275) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -46822,7 +47690,7 @@ func (p *MDLParser) WidgetPropertiesV3() (localctx IWidgetPropertiesV3Context) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3205) + p.SetState(3276) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -47288,8 +48156,8 @@ func (s *WidgetPropertyV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { localctx = NewWidgetPropertyV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 374, MDLParserRULE_widgetPropertyV3) - p.SetState(3282) + p.EnterRule(localctx, 378, MDLParserRULE_widgetPropertyV3) + p.SetState(3353) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -47299,7 +48167,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { case MDLParserDATASOURCE: p.EnterOuterAlt(localctx, 1) { - p.SetState(3207) + p.SetState(3278) p.Match(MDLParserDATASOURCE) if p.HasError() { // Recognition error - abort rule @@ -47307,7 +48175,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3208) + p.SetState(3279) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47315,14 +48183,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3209) + p.SetState(3280) p.DataSourceExprV3() } case MDLParserATTRIBUTE: p.EnterOuterAlt(localctx, 2) { - p.SetState(3210) + p.SetState(3281) p.Match(MDLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule @@ -47330,7 +48198,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3211) + p.SetState(3282) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47338,14 +48206,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3212) + p.SetState(3283) p.AttributePathV3() } case MDLParserBINDS: p.EnterOuterAlt(localctx, 3) { - p.SetState(3213) + p.SetState(3284) p.Match(MDLParserBINDS) if p.HasError() { // Recognition error - abort rule @@ -47353,7 +48221,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3214) + p.SetState(3285) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47361,14 +48229,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3215) + p.SetState(3286) p.AttributePathV3() } case MDLParserACTION: p.EnterOuterAlt(localctx, 4) { - p.SetState(3216) + p.SetState(3287) p.Match(MDLParserACTION) if p.HasError() { // Recognition error - abort rule @@ -47376,7 +48244,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3217) + p.SetState(3288) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47384,14 +48252,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3218) + p.SetState(3289) p.ActionExprV3() } case MDLParserCAPTION: p.EnterOuterAlt(localctx, 5) { - p.SetState(3219) + p.SetState(3290) p.Match(MDLParserCAPTION) if p.HasError() { // Recognition error - abort rule @@ -47399,7 +48267,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3220) + p.SetState(3291) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47407,14 +48275,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3221) + p.SetState(3292) p.StringExprV3() } case MDLParserLABEL: p.EnterOuterAlt(localctx, 6) { - p.SetState(3222) + p.SetState(3293) p.Match(MDLParserLABEL) if p.HasError() { // Recognition error - abort rule @@ -47422,7 +48290,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3223) + p.SetState(3294) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47430,7 +48298,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3224) + p.SetState(3295) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -47441,7 +48309,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { case MDLParserATTR: p.EnterOuterAlt(localctx, 7) { - p.SetState(3225) + p.SetState(3296) p.Match(MDLParserATTR) if p.HasError() { // Recognition error - abort rule @@ -47449,7 +48317,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3226) + p.SetState(3297) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47457,14 +48325,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3227) + p.SetState(3298) p.AttributePathV3() } case MDLParserCONTENT: p.EnterOuterAlt(localctx, 8) { - p.SetState(3228) + p.SetState(3299) p.Match(MDLParserCONTENT) if p.HasError() { // Recognition error - abort rule @@ -47472,7 +48340,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3229) + p.SetState(3300) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47480,14 +48348,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3230) + p.SetState(3301) p.StringExprV3() } case MDLParserRENDERMODE: p.EnterOuterAlt(localctx, 9) { - p.SetState(3231) + p.SetState(3302) p.Match(MDLParserRENDERMODE) if p.HasError() { // Recognition error - abort rule @@ -47495,7 +48363,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3232) + p.SetState(3303) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47503,14 +48371,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3233) + p.SetState(3304) p.RenderModeV3() } case MDLParserCONTENTPARAMS: p.EnterOuterAlt(localctx, 10) { - p.SetState(3234) + p.SetState(3305) p.Match(MDLParserCONTENTPARAMS) if p.HasError() { // Recognition error - abort rule @@ -47518,7 +48386,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3235) + p.SetState(3306) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47526,14 +48394,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3236) + p.SetState(3307) p.ParamListV3() } case MDLParserCAPTIONPARAMS: p.EnterOuterAlt(localctx, 11) { - p.SetState(3237) + p.SetState(3308) p.Match(MDLParserCAPTIONPARAMS) if p.HasError() { // Recognition error - abort rule @@ -47541,7 +48409,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3238) + p.SetState(3309) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47549,14 +48417,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3239) + p.SetState(3310) p.ParamListV3() } case MDLParserBUTTONSTYLE: p.EnterOuterAlt(localctx, 12) { - p.SetState(3240) + p.SetState(3311) p.Match(MDLParserBUTTONSTYLE) if p.HasError() { // Recognition error - abort rule @@ -47564,7 +48432,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3241) + p.SetState(3312) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47572,14 +48440,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3242) + p.SetState(3313) p.ButtonStyleV3() } case MDLParserCLASS: p.EnterOuterAlt(localctx, 13) { - p.SetState(3243) + p.SetState(3314) p.Match(MDLParserCLASS) if p.HasError() { // Recognition error - abort rule @@ -47587,7 +48455,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3244) + p.SetState(3315) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47595,7 +48463,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3245) + p.SetState(3316) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -47606,7 +48474,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { case MDLParserSTYLE: p.EnterOuterAlt(localctx, 14) { - p.SetState(3246) + p.SetState(3317) p.Match(MDLParserSTYLE) if p.HasError() { // Recognition error - abort rule @@ -47614,7 +48482,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3247) + p.SetState(3318) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47622,7 +48490,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3248) + p.SetState(3319) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -47633,7 +48501,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { case MDLParserDESKTOPWIDTH: p.EnterOuterAlt(localctx, 15) { - p.SetState(3249) + p.SetState(3320) p.Match(MDLParserDESKTOPWIDTH) if p.HasError() { // Recognition error - abort rule @@ -47641,7 +48509,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3250) + p.SetState(3321) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47649,14 +48517,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3251) + p.SetState(3322) p.DesktopWidthV3() } case MDLParserSELECTION: p.EnterOuterAlt(localctx, 16) { - p.SetState(3252) + p.SetState(3323) p.Match(MDLParserSELECTION) if p.HasError() { // Recognition error - abort rule @@ -47664,7 +48532,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3253) + p.SetState(3324) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47672,14 +48540,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3254) + p.SetState(3325) p.SelectionModeV3() } case MDLParserSNIPPET: p.EnterOuterAlt(localctx, 17) { - p.SetState(3255) + p.SetState(3326) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -47687,7 +48555,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3256) + p.SetState(3327) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47695,14 +48563,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3257) + p.SetState(3328) p.QualifiedName() } case MDLParserATTRIBUTES: p.EnterOuterAlt(localctx, 18) { - p.SetState(3258) + p.SetState(3329) p.Match(MDLParserATTRIBUTES) if p.HasError() { // Recognition error - abort rule @@ -47710,7 +48578,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3259) + p.SetState(3330) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47718,14 +48586,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3260) + p.SetState(3331) p.AttributeListV3() } case MDLParserFILTERTYPE: p.EnterOuterAlt(localctx, 19) { - p.SetState(3261) + p.SetState(3332) p.Match(MDLParserFILTERTYPE) if p.HasError() { // Recognition error - abort rule @@ -47733,7 +48601,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3262) + p.SetState(3333) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47741,14 +48609,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3263) + p.SetState(3334) p.FilterTypeValue() } case MDLParserDESIGNPROPERTIES: p.EnterOuterAlt(localctx, 20) { - p.SetState(3264) + p.SetState(3335) p.Match(MDLParserDESIGNPROPERTIES) if p.HasError() { // Recognition error - abort rule @@ -47756,7 +48624,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3265) + p.SetState(3336) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47764,14 +48632,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3266) + p.SetState(3337) p.DesignPropertyListV3() } case MDLParserWIDTH: p.EnterOuterAlt(localctx, 21) { - p.SetState(3267) + p.SetState(3338) p.Match(MDLParserWIDTH) if p.HasError() { // Recognition error - abort rule @@ -47779,7 +48647,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3268) + p.SetState(3339) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47787,7 +48655,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3269) + p.SetState(3340) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -47798,7 +48666,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { case MDLParserHEIGHT: p.EnterOuterAlt(localctx, 22) { - p.SetState(3270) + p.SetState(3341) p.Match(MDLParserHEIGHT) if p.HasError() { // Recognition error - abort rule @@ -47806,7 +48674,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3271) + p.SetState(3342) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47814,7 +48682,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3272) + p.SetState(3343) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -47825,7 +48693,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { case MDLParserVISIBLE: p.EnterOuterAlt(localctx, 23) { - p.SetState(3273) + p.SetState(3344) p.Match(MDLParserVISIBLE) if p.HasError() { // Recognition error - abort rule @@ -47833,7 +48701,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3274) + p.SetState(3345) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47841,14 +48709,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3275) + p.SetState(3346) p.PropertyValueV3() } case MDLParserTOOLTIP: p.EnterOuterAlt(localctx, 24) { - p.SetState(3276) + p.SetState(3347) p.Match(MDLParserTOOLTIP) if p.HasError() { // Recognition error - abort rule @@ -47856,7 +48724,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3277) + p.SetState(3348) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47864,14 +48732,14 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3278) + p.SetState(3349) p.PropertyValueV3() } case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 25) { - p.SetState(3279) + p.SetState(3350) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -47879,7 +48747,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3280) + p.SetState(3351) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -47887,7 +48755,7 @@ func (p *MDLParser) WidgetPropertyV3() (localctx IWidgetPropertyV3Context) { } } { - p.SetState(3281) + p.SetState(3352) p.PropertyValueV3() } @@ -47991,12 +48859,12 @@ func (s *FilterTypeValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) FilterTypeValue() (localctx IFilterTypeValueContext) { localctx = NewFilterTypeValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 376, MDLParserRULE_filterTypeValue) + p.EnterRule(localctx, 380, MDLParserRULE_filterTypeValue) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3284) + p.SetState(3355) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserCONTAINS || _la == MDLParserEMPTY || _la == MDLParserIDENTIFIER) { @@ -48150,12 +49018,12 @@ func (s *AttributeListV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AttributeListV3() (localctx IAttributeListV3Context) { localctx = NewAttributeListV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 378, MDLParserRULE_attributeListV3) + p.EnterRule(localctx, 382, MDLParserRULE_attributeListV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3286) + p.SetState(3357) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -48163,10 +49031,10 @@ func (p *MDLParser) AttributeListV3() (localctx IAttributeListV3Context) { } } { - p.SetState(3287) + p.SetState(3358) p.QualifiedName() } - p.SetState(3292) + p.SetState(3363) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48175,7 +49043,7 @@ func (p *MDLParser) AttributeListV3() (localctx IAttributeListV3Context) { for _la == MDLParserCOMMA { { - p.SetState(3288) + p.SetState(3359) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -48183,11 +49051,11 @@ func (p *MDLParser) AttributeListV3() (localctx IAttributeListV3Context) { } } { - p.SetState(3289) + p.SetState(3360) p.QualifiedName() } - p.SetState(3294) + p.SetState(3365) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48195,7 +49063,7 @@ func (p *MDLParser) AttributeListV3() (localctx IAttributeListV3Context) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3295) + p.SetState(3366) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -48540,12 +49408,12 @@ func (s *DataSourceExprV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { localctx = NewDataSourceExprV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 380, MDLParserRULE_dataSourceExprV3) + p.EnterRule(localctx, 384, MDLParserRULE_dataSourceExprV3) var _la int var _alt int - p.SetState(3343) + p.SetState(3414) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48555,7 +49423,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { case MDLParserVARIABLE: p.EnterOuterAlt(localctx, 1) { - p.SetState(3297) + p.SetState(3368) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -48566,19 +49434,19 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { case MDLParserDATABASE: p.EnterOuterAlt(localctx, 2) { - p.SetState(3298) + p.SetState(3369) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3300) + p.SetState(3371) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 328, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 331, p.GetParserRuleContext()) == 1 { { - p.SetState(3299) + p.SetState(3370) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -48590,10 +49458,10 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { goto errorExit } { - p.SetState(3302) + p.SetState(3373) p.QualifiedName() } - p.SetState(3316) + p.SetState(3387) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48602,14 +49470,14 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { if _la == MDLParserWHERE { { - p.SetState(3303) + p.SetState(3374) p.Match(MDLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3314) + p.SetState(3385) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48618,10 +49486,10 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { switch p.GetTokenStream().LA(1) { case MDLParserLBRACKET: { - p.SetState(3304) + p.SetState(3375) p.XpathConstraint() } - p.SetState(3310) + p.SetState(3381) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48630,15 +49498,15 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { for _la == MDLParserAND || _la == MDLParserOR { { - p.SetState(3305) + p.SetState(3376) p.AndOrXpath() } { - p.SetState(3306) + p.SetState(3377) p.XpathConstraint() } - p.SetState(3312) + p.SetState(3383) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48646,9 +49514,9 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { _la = p.GetTokenStream().LA(1) } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: { - p.SetState(3313) + p.SetState(3384) p.Expression() } @@ -48658,7 +49526,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { } } - p.SetState(3327) + p.SetState(3398) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48667,7 +49535,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { if _la == MDLParserSORT_BY { { - p.SetState(3318) + p.SetState(3389) p.Match(MDLParserSORT_BY) if p.HasError() { // Recognition error - abort rule @@ -48675,22 +49543,22 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { } } { - p.SetState(3319) + p.SetState(3390) p.SortColumn() } - p.SetState(3324) + p.SetState(3395) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 332, p.GetParserRuleContext()) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 335, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { - p.SetState(3320) + p.SetState(3391) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -48698,17 +49566,17 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { } } { - p.SetState(3321) + p.SetState(3392) p.SortColumn() } } - p.SetState(3326) + p.SetState(3397) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 332, p.GetParserRuleContext()) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 335, p.GetParserRuleContext()) if p.HasError() { goto errorExit } @@ -48719,7 +49587,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { case MDLParserMICROFLOW: p.EnterOuterAlt(localctx, 3) { - p.SetState(3329) + p.SetState(3400) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -48727,10 +49595,10 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { } } { - p.SetState(3330) + p.SetState(3401) p.QualifiedName() } - p.SetState(3332) + p.SetState(3403) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48739,7 +49607,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { if _la == MDLParserLPAREN { { - p.SetState(3331) + p.SetState(3402) p.MicroflowArgsV3() } @@ -48748,7 +49616,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { case MDLParserNANOFLOW: p.EnterOuterAlt(localctx, 4) { - p.SetState(3334) + p.SetState(3405) p.Match(MDLParserNANOFLOW) if p.HasError() { // Recognition error - abort rule @@ -48756,10 +49624,10 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { } } { - p.SetState(3335) + p.SetState(3406) p.QualifiedName() } - p.SetState(3337) + p.SetState(3408) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -48768,7 +49636,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { if _la == MDLParserLPAREN { { - p.SetState(3336) + p.SetState(3407) p.MicroflowArgsV3() } @@ -48777,7 +49645,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { case MDLParserASSOCIATION: p.EnterOuterAlt(localctx, 5) { - p.SetState(3339) + p.SetState(3410) p.Match(MDLParserASSOCIATION) if p.HasError() { // Recognition error - abort rule @@ -48785,14 +49653,14 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { } } { - p.SetState(3340) + p.SetState(3411) p.AttributePathV3() } case MDLParserSELECTION: p.EnterOuterAlt(localctx, 6) { - p.SetState(3341) + p.SetState(3412) p.Match(MDLParserSELECTION) if p.HasError() { // Recognition error - abort rule @@ -48800,7 +49668,7 @@ func (p *MDLParser) DataSourceExprV3() (localctx IDataSourceExprV3Context) { } } { - p.SetState(3342) + p.SetState(3413) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -49009,10 +49877,10 @@ func (s *ActionExprV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { localctx = NewActionExprV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 382, MDLParserRULE_actionExprV3) + p.EnterRule(localctx, 386, MDLParserRULE_actionExprV3) var _la int - p.SetState(3383) + p.SetState(3454) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49022,14 +49890,14 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserSAVE_CHANGES: p.EnterOuterAlt(localctx, 1) { - p.SetState(3345) + p.SetState(3416) p.Match(MDLParserSAVE_CHANGES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3347) + p.SetState(3418) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49038,7 +49906,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { if _la == MDLParserCLOSE_PAGE { { - p.SetState(3346) + p.SetState(3417) p.Match(MDLParserCLOSE_PAGE) if p.HasError() { // Recognition error - abort rule @@ -49051,14 +49919,14 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserCANCEL_CHANGES: p.EnterOuterAlt(localctx, 2) { - p.SetState(3349) + p.SetState(3420) p.Match(MDLParserCANCEL_CHANGES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3351) + p.SetState(3422) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49067,7 +49935,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { if _la == MDLParserCLOSE_PAGE { { - p.SetState(3350) + p.SetState(3421) p.Match(MDLParserCLOSE_PAGE) if p.HasError() { // Recognition error - abort rule @@ -49080,7 +49948,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserCLOSE_PAGE: p.EnterOuterAlt(localctx, 3) { - p.SetState(3353) + p.SetState(3424) p.Match(MDLParserCLOSE_PAGE) if p.HasError() { // Recognition error - abort rule @@ -49091,7 +49959,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserDELETE_OBJECT: p.EnterOuterAlt(localctx, 4) { - p.SetState(3354) + p.SetState(3425) p.Match(MDLParserDELETE_OBJECT) if p.HasError() { // Recognition error - abort rule @@ -49102,14 +49970,14 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserDELETE: p.EnterOuterAlt(localctx, 5) { - p.SetState(3355) + p.SetState(3426) p.Match(MDLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3357) + p.SetState(3428) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49118,7 +49986,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { if _la == MDLParserCLOSE_PAGE { { - p.SetState(3356) + p.SetState(3427) p.Match(MDLParserCLOSE_PAGE) if p.HasError() { // Recognition error - abort rule @@ -49131,7 +49999,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserCREATE_OBJECT: p.EnterOuterAlt(localctx, 6) { - p.SetState(3359) + p.SetState(3430) p.Match(MDLParserCREATE_OBJECT) if p.HasError() { // Recognition error - abort rule @@ -49139,10 +50007,10 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { } } { - p.SetState(3360) + p.SetState(3431) p.QualifiedName() } - p.SetState(3363) + p.SetState(3434) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49151,7 +50019,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { if _la == MDLParserTHEN { { - p.SetState(3361) + p.SetState(3432) p.Match(MDLParserTHEN) if p.HasError() { // Recognition error - abort rule @@ -49159,7 +50027,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { } } { - p.SetState(3362) + p.SetState(3433) p.ActionExprV3() } @@ -49168,7 +50036,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserSHOW_PAGE: p.EnterOuterAlt(localctx, 7) { - p.SetState(3365) + p.SetState(3436) p.Match(MDLParserSHOW_PAGE) if p.HasError() { // Recognition error - abort rule @@ -49176,10 +50044,10 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { } } { - p.SetState(3366) + p.SetState(3437) p.QualifiedName() } - p.SetState(3368) + p.SetState(3439) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49188,7 +50056,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { if _la == MDLParserLPAREN { { - p.SetState(3367) + p.SetState(3438) p.MicroflowArgsV3() } @@ -49197,7 +50065,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserMICROFLOW: p.EnterOuterAlt(localctx, 8) { - p.SetState(3370) + p.SetState(3441) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -49205,10 +50073,10 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { } } { - p.SetState(3371) + p.SetState(3442) p.QualifiedName() } - p.SetState(3373) + p.SetState(3444) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49217,7 +50085,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { if _la == MDLParserLPAREN { { - p.SetState(3372) + p.SetState(3443) p.MicroflowArgsV3() } @@ -49226,7 +50094,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserNANOFLOW: p.EnterOuterAlt(localctx, 9) { - p.SetState(3375) + p.SetState(3446) p.Match(MDLParserNANOFLOW) if p.HasError() { // Recognition error - abort rule @@ -49234,10 +50102,10 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { } } { - p.SetState(3376) + p.SetState(3447) p.QualifiedName() } - p.SetState(3378) + p.SetState(3449) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49246,7 +50114,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { if _la == MDLParserLPAREN { { - p.SetState(3377) + p.SetState(3448) p.MicroflowArgsV3() } @@ -49255,7 +50123,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserOPEN_LINK: p.EnterOuterAlt(localctx, 10) { - p.SetState(3380) + p.SetState(3451) p.Match(MDLParserOPEN_LINK) if p.HasError() { // Recognition error - abort rule @@ -49263,7 +50131,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { } } { - p.SetState(3381) + p.SetState(3452) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -49274,7 +50142,7 @@ func (p *MDLParser) ActionExprV3() (localctx IActionExprV3Context) { case MDLParserSIGN_OUT: p.EnterOuterAlt(localctx, 11) { - p.SetState(3382) + p.SetState(3453) p.Match(MDLParserSIGN_OUT) if p.HasError() { // Recognition error - abort rule @@ -49430,12 +50298,12 @@ func (s *MicroflowArgsV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MicroflowArgsV3() (localctx IMicroflowArgsV3Context) { localctx = NewMicroflowArgsV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 384, MDLParserRULE_microflowArgsV3) + p.EnterRule(localctx, 388, MDLParserRULE_microflowArgsV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3385) + p.SetState(3456) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -49443,10 +50311,10 @@ func (p *MDLParser) MicroflowArgsV3() (localctx IMicroflowArgsV3Context) { } } { - p.SetState(3386) + p.SetState(3457) p.MicroflowArgV3() } - p.SetState(3391) + p.SetState(3462) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49455,7 +50323,7 @@ func (p *MDLParser) MicroflowArgsV3() (localctx IMicroflowArgsV3Context) { for _la == MDLParserCOMMA { { - p.SetState(3387) + p.SetState(3458) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -49463,11 +50331,11 @@ func (p *MDLParser) MicroflowArgsV3() (localctx IMicroflowArgsV3Context) { } } { - p.SetState(3388) + p.SetState(3459) p.MicroflowArgV3() } - p.SetState(3393) + p.SetState(3464) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49475,7 +50343,7 @@ func (p *MDLParser) MicroflowArgsV3() (localctx IMicroflowArgsV3Context) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3394) + p.SetState(3465) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -49600,8 +50468,8 @@ func (s *MicroflowArgV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) MicroflowArgV3() (localctx IMicroflowArgV3Context) { localctx = NewMicroflowArgV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 386, MDLParserRULE_microflowArgV3) - p.SetState(3402) + p.EnterRule(localctx, 390, MDLParserRULE_microflowArgV3) + p.SetState(3473) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49611,7 +50479,7 @@ func (p *MDLParser) MicroflowArgV3() (localctx IMicroflowArgV3Context) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(3396) + p.SetState(3467) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -49619,7 +50487,7 @@ func (p *MDLParser) MicroflowArgV3() (localctx IMicroflowArgV3Context) { } } { - p.SetState(3397) + p.SetState(3468) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -49627,14 +50495,14 @@ func (p *MDLParser) MicroflowArgV3() (localctx IMicroflowArgV3Context) { } } { - p.SetState(3398) + p.SetState(3469) p.Expression() } case MDLParserVARIABLE: p.EnterOuterAlt(localctx, 2) { - p.SetState(3399) + p.SetState(3470) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule @@ -49642,7 +50510,7 @@ func (p *MDLParser) MicroflowArgV3() (localctx IMicroflowArgV3Context) { } } { - p.SetState(3400) + p.SetState(3471) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -49650,7 +50518,7 @@ func (p *MDLParser) MicroflowArgV3() (localctx IMicroflowArgV3Context) { } } { - p.SetState(3401) + p.SetState(3472) p.Expression() } @@ -49812,11 +50680,11 @@ func (s *AttributePathV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { localctx = NewAttributePathV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 388, MDLParserRULE_attributePathV3) + p.EnterRule(localctx, 392, MDLParserRULE_attributePathV3) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(3407) + p.SetState(3478) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49825,7 +50693,7 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { switch p.GetTokenStream().LA(1) { case MDLParserIDENTIFIER: { - p.SetState(3404) + p.SetState(3475) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -49835,7 +50703,7 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { case MDLParserQUOTED_IDENTIFIER: { - p.SetState(3405) + p.SetState(3476) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -49843,9 +50711,9 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { } } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: { - p.SetState(3406) + p.SetState(3477) p.Keyword() } @@ -49853,7 +50721,7 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } - p.SetState(3417) + p.SetState(3488) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49862,14 +50730,14 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { for _la == MDLParserSLASH { { - p.SetState(3409) + p.SetState(3480) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3413) + p.SetState(3484) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -49878,7 +50746,7 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { switch p.GetTokenStream().LA(1) { case MDLParserIDENTIFIER: { - p.SetState(3410) + p.SetState(3481) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -49888,7 +50756,7 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { case MDLParserQUOTED_IDENTIFIER: { - p.SetState(3411) + p.SetState(3482) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -49896,9 +50764,9 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { } } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: { - p.SetState(3412) + p.SetState(3483) p.Keyword() } @@ -49907,7 +50775,7 @@ func (p *MDLParser) AttributePathV3() (localctx IAttributePathV3Context) { goto errorExit } - p.SetState(3419) + p.SetState(3490) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -50049,10 +50917,10 @@ func (s *StringExprV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) StringExprV3() (localctx IStringExprV3Context) { localctx = NewStringExprV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 390, MDLParserRULE_stringExprV3) + p.EnterRule(localctx, 394, MDLParserRULE_stringExprV3) var _la int - p.SetState(3430) + p.SetState(3501) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -50062,7 +50930,7 @@ func (p *MDLParser) StringExprV3() (localctx IStringExprV3Context) { case MDLParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 1) { - p.SetState(3420) + p.SetState(3491) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -50070,24 +50938,24 @@ func (p *MDLParser) StringExprV3() (localctx IStringExprV3Context) { } } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(3421) + p.SetState(3492) p.AttributePathV3() } case MDLParserVARIABLE: p.EnterOuterAlt(localctx, 3) { - p.SetState(3422) + p.SetState(3493) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3428) + p.SetState(3499) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -50096,14 +50964,14 @@ func (p *MDLParser) StringExprV3() (localctx IStringExprV3Context) { if _la == MDLParserDOT { { - p.SetState(3423) + p.SetState(3494) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3426) + p.SetState(3497) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -50112,7 +50980,7 @@ func (p *MDLParser) StringExprV3() (localctx IStringExprV3Context) { switch p.GetTokenStream().LA(1) { case MDLParserIDENTIFIER: { - p.SetState(3424) + p.SetState(3495) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -50120,9 +50988,9 @@ func (p *MDLParser) StringExprV3() (localctx IStringExprV3Context) { } } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: { - p.SetState(3425) + p.SetState(3496) p.Keyword() } @@ -50281,12 +51149,12 @@ func (s *ParamListV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ParamListV3() (localctx IParamListV3Context) { localctx = NewParamListV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 392, MDLParserRULE_paramListV3) + p.EnterRule(localctx, 396, MDLParserRULE_paramListV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3432) + p.SetState(3503) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -50294,10 +51162,10 @@ func (p *MDLParser) ParamListV3() (localctx IParamListV3Context) { } } { - p.SetState(3433) + p.SetState(3504) p.ParamAssignmentV3() } - p.SetState(3438) + p.SetState(3509) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -50306,7 +51174,7 @@ func (p *MDLParser) ParamListV3() (localctx IParamListV3Context) { for _la == MDLParserCOMMA { { - p.SetState(3434) + p.SetState(3505) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -50314,11 +51182,11 @@ func (p *MDLParser) ParamListV3() (localctx IParamListV3Context) { } } { - p.SetState(3435) + p.SetState(3506) p.ParamAssignmentV3() } - p.SetState(3440) + p.SetState(3511) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -50326,7 +51194,7 @@ func (p *MDLParser) ParamListV3() (localctx IParamListV3Context) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3441) + p.SetState(3512) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -50451,10 +51319,10 @@ func (s *ParamAssignmentV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ParamAssignmentV3() (localctx IParamAssignmentV3Context) { localctx = NewParamAssignmentV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 394, MDLParserRULE_paramAssignmentV3) + p.EnterRule(localctx, 398, MDLParserRULE_paramAssignmentV3) p.EnterOuterAlt(localctx, 1) { - p.SetState(3443) + p.SetState(3514) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -50462,7 +51330,7 @@ func (p *MDLParser) ParamAssignmentV3() (localctx IParamAssignmentV3Context) { } } { - p.SetState(3444) + p.SetState(3515) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -50470,7 +51338,7 @@ func (p *MDLParser) ParamAssignmentV3() (localctx IParamAssignmentV3Context) { } } { - p.SetState(3445) + p.SetState(3516) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -50478,7 +51346,7 @@ func (p *MDLParser) ParamAssignmentV3() (localctx IParamAssignmentV3Context) { } } { - p.SetState(3446) + p.SetState(3517) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -50486,7 +51354,7 @@ func (p *MDLParser) ParamAssignmentV3() (localctx IParamAssignmentV3Context) { } } { - p.SetState(3447) + p.SetState(3518) p.Expression() } @@ -50615,12 +51483,12 @@ func (s *RenderModeV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RenderModeV3() (localctx IRenderModeV3Context) { localctx = NewRenderModeV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 396, MDLParserRULE_renderModeV3) + p.EnterRule(localctx, 400, MDLParserRULE_renderModeV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3449) + p.SetState(3520) _la = p.GetTokenStream().LA(1) if !(((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&127) != 0) || _la == MDLParserTEXT || _la == MDLParserIDENTIFIER) { @@ -50756,12 +51624,12 @@ func (s *ButtonStyleV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ButtonStyleV3() (localctx IButtonStyleV3Context) { localctx = NewButtonStyleV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 398, MDLParserRULE_buttonStyleV3) + p.EnterRule(localctx, 402, MDLParserRULE_buttonStyleV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3451) + p.SetState(3522) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserINFO || _la == MDLParserWARNING || ((int64((_la-241)) & ^0x3f) == 0 && ((int64(1)<<(_la-241))&562949953421343) != 0) || _la == MDLParserIDENTIFIER) { @@ -50862,12 +51730,12 @@ func (s *DesktopWidthV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DesktopWidthV3() (localctx IDesktopWidthV3Context) { localctx = NewDesktopWidthV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 400, MDLParserRULE_desktopWidthV3) + p.EnterRule(localctx, 404, MDLParserRULE_desktopWidthV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3453) + p.SetState(3524) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserAUTOFILL || _la == MDLParserNUMBER_LITERAL) { @@ -50973,15 +51841,15 @@ func (s *SelectionModeV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SelectionModeV3() (localctx ISelectionModeV3Context) { localctx = NewSelectionModeV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 402, MDLParserRULE_selectionModeV3) + p.EnterRule(localctx, 406, MDLParserRULE_selectionModeV3) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3455) + p.SetState(3526) _la = p.GetTokenStream().LA(1) - if !((int64((_la-406)) & ^0x3f) == 0 && ((int64(1)<<(_la-406))&7) != 0) { + if !((int64((_la-407)) & ^0x3f) == 0 && ((int64(1)<<(_la-407))&7) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -51211,20 +52079,20 @@ func (s *PropertyValueV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { localctx = NewPropertyValueV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 404, MDLParserRULE_propertyValueV3) + p.EnterRule(localctx, 408, MDLParserRULE_propertyValueV3) var _la int - p.SetState(3480) + p.SetState(3551) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 356, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 359, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(3457) + p.SetState(3528) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -51235,7 +52103,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(3458) + p.SetState(3529) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -51246,21 +52114,21 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(3459) + p.SetState(3530) p.BooleanLiteral() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(3460) + p.SetState(3531) p.QualifiedName() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(3461) + p.SetState(3532) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -51271,7 +52139,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(3462) + p.SetState(3533) p.Match(MDLParserH1) if p.HasError() { // Recognition error - abort rule @@ -51282,7 +52150,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(3463) + p.SetState(3534) p.Match(MDLParserH2) if p.HasError() { // Recognition error - abort rule @@ -51293,7 +52161,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(3464) + p.SetState(3535) p.Match(MDLParserH3) if p.HasError() { // Recognition error - abort rule @@ -51304,7 +52172,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(3465) + p.SetState(3536) p.Match(MDLParserH4) if p.HasError() { // Recognition error - abort rule @@ -51315,7 +52183,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(3466) + p.SetState(3537) p.Match(MDLParserH5) if p.HasError() { // Recognition error - abort rule @@ -51326,7 +52194,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(3467) + p.SetState(3538) p.Match(MDLParserH6) if p.HasError() { // Recognition error - abort rule @@ -51337,26 +52205,26 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(3468) + p.SetState(3539) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3477) + p.SetState(3548) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256446305633024) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-9108493575434249) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1836844262852001929) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&22236590921218055) != 0) || ((int64((_la-257)) & ^0x3f) == 0 && ((int64(1)<<(_la-257))&-213306331643393) != 0) || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&-9007233614479601) != 0) || ((int64((_la-386)) & ^0x3f) == 0 && ((int64(1)<<(_la-386))&4611685824080116567) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2105541731) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256450600600320) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-9108493575434249) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1836844262852001929) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&22236590921218055) != 0) || ((int64((_la-257)) & ^0x3f) == 0 && ((int64(1)<<(_la-257))&-494781308354049) != 0) || ((int64((_la-321)) & ^0x3f) == 0 && ((int64(1)<<(_la-321))&-36028934457918403) != 0) || ((int64((_la-385)) & ^0x3f) == 0 && ((int64(1)<<(_la-385))&-777389085345) != 0) || ((int64((_la-449)) & ^0x3f) == 0 && ((int64(1)<<(_la-449))&141300513672913151) != 0) { { - p.SetState(3469) + p.SetState(3540) p.Expression() } - p.SetState(3474) + p.SetState(3545) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -51365,7 +52233,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { for _la == MDLParserCOMMA { { - p.SetState(3470) + p.SetState(3541) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -51373,11 +52241,11 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { } } { - p.SetState(3471) + p.SetState(3542) p.Expression() } - p.SetState(3476) + p.SetState(3547) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -51387,7 +52255,7 @@ func (p *MDLParser) PropertyValueV3() (localctx IPropertyValueV3Context) { } { - p.SetState(3479) + p.SetState(3550) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -51542,20 +52410,20 @@ func (s *DesignPropertyListV3Context) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) DesignPropertyListV3() (localctx IDesignPropertyListV3Context) { localctx = NewDesignPropertyListV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 406, MDLParserRULE_designPropertyListV3) + p.EnterRule(localctx, 410, MDLParserRULE_designPropertyListV3) var _la int - p.SetState(3495) + p.SetState(3566) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 358, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 361, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(3482) + p.SetState(3553) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -51563,10 +52431,10 @@ func (p *MDLParser) DesignPropertyListV3() (localctx IDesignPropertyListV3Contex } } { - p.SetState(3483) + p.SetState(3554) p.DesignPropertyEntryV3() } - p.SetState(3488) + p.SetState(3559) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -51575,7 +52443,7 @@ func (p *MDLParser) DesignPropertyListV3() (localctx IDesignPropertyListV3Contex for _la == MDLParserCOMMA { { - p.SetState(3484) + p.SetState(3555) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -51583,11 +52451,11 @@ func (p *MDLParser) DesignPropertyListV3() (localctx IDesignPropertyListV3Contex } } { - p.SetState(3485) + p.SetState(3556) p.DesignPropertyEntryV3() } - p.SetState(3490) + p.SetState(3561) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -51595,7 +52463,7 @@ func (p *MDLParser) DesignPropertyListV3() (localctx IDesignPropertyListV3Contex _la = p.GetTokenStream().LA(1) } { - p.SetState(3491) + p.SetState(3562) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -51606,7 +52474,7 @@ func (p *MDLParser) DesignPropertyListV3() (localctx IDesignPropertyListV3Contex case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(3493) + p.SetState(3564) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule @@ -51614,7 +52482,7 @@ func (p *MDLParser) DesignPropertyListV3() (localctx IDesignPropertyListV3Contex } } { - p.SetState(3494) + p.SetState(3565) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -51731,18 +52599,18 @@ func (s *DesignPropertyEntryV3Context) ExitRule(listener antlr.ParseTreeListener func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Context) { localctx = NewDesignPropertyEntryV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 408, MDLParserRULE_designPropertyEntryV3) - p.SetState(3506) + p.EnterRule(localctx, 412, MDLParserRULE_designPropertyEntryV3) + p.SetState(3577) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 359, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 362, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(3497) + p.SetState(3568) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -51750,7 +52618,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont } } { - p.SetState(3498) + p.SetState(3569) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -51758,7 +52626,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont } } { - p.SetState(3499) + p.SetState(3570) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -51769,7 +52637,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(3500) + p.SetState(3571) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -51777,7 +52645,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont } } { - p.SetState(3501) + p.SetState(3572) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -51785,7 +52653,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont } } { - p.SetState(3502) + p.SetState(3573) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -51796,7 +52664,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(3503) + p.SetState(3574) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -51804,7 +52672,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont } } { - p.SetState(3504) + p.SetState(3575) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -51812,7 +52680,7 @@ func (p *MDLParser) DesignPropertyEntryV3() (localctx IDesignPropertyEntryV3Cont } } { - p.SetState(3505) + p.SetState(3576) p.Match(MDLParserOFF) if p.HasError() { // Recognition error - abort rule @@ -51931,10 +52799,10 @@ func (s *WidgetBodyV3Context) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WidgetBodyV3() (localctx IWidgetBodyV3Context) { localctx = NewWidgetBodyV3Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 410, MDLParserRULE_widgetBodyV3) + p.EnterRule(localctx, 414, MDLParserRULE_widgetBodyV3) p.EnterOuterAlt(localctx, 1) { - p.SetState(3508) + p.SetState(3579) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -51942,11 +52810,11 @@ func (p *MDLParser) WidgetBodyV3() (localctx IWidgetBodyV3Context) { } } { - p.SetState(3509) + p.SetState(3580) p.PageBodyV3() } { - p.SetState(3510) + p.SetState(3581) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -52126,12 +52994,12 @@ func (s *CreateNotebookStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) CreateNotebookStatement() (localctx ICreateNotebookStatementContext) { localctx = NewCreateNotebookStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 412, MDLParserRULE_createNotebookStatement) + p.EnterRule(localctx, 416, MDLParserRULE_createNotebookStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3512) + p.SetState(3583) p.Match(MDLParserNOTEBOOK) if p.HasError() { // Recognition error - abort rule @@ -52139,10 +53007,10 @@ func (p *MDLParser) CreateNotebookStatement() (localctx ICreateNotebookStatement } } { - p.SetState(3513) + p.SetState(3584) p.QualifiedName() } - p.SetState(3515) + p.SetState(3586) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52151,20 +53019,20 @@ func (p *MDLParser) CreateNotebookStatement() (localctx ICreateNotebookStatement if _la == MDLParserCOMMENT { { - p.SetState(3514) + p.SetState(3585) p.NotebookOptions() } } { - p.SetState(3517) + p.SetState(3588) p.Match(MDLParserBEGIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3521) + p.SetState(3592) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52173,11 +53041,11 @@ func (p *MDLParser) CreateNotebookStatement() (localctx ICreateNotebookStatement for _la == MDLParserPAGE { { - p.SetState(3518) + p.SetState(3589) p.NotebookPage() } - p.SetState(3523) + p.SetState(3594) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52185,7 +53053,7 @@ func (p *MDLParser) CreateNotebookStatement() (localctx ICreateNotebookStatement _la = p.GetTokenStream().LA(1) } { - p.SetState(3524) + p.SetState(3595) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule @@ -52316,11 +53184,11 @@ func (s *NotebookOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) NotebookOptions() (localctx INotebookOptionsContext) { localctx = NewNotebookOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 414, MDLParserRULE_notebookOptions) + p.EnterRule(localctx, 418, MDLParserRULE_notebookOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(3527) + p.SetState(3598) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52329,11 +53197,11 @@ func (p *MDLParser) NotebookOptions() (localctx INotebookOptionsContext) { for ok := true; ok; ok = _la == MDLParserCOMMENT { { - p.SetState(3526) + p.SetState(3597) p.NotebookOption() } - p.SetState(3529) + p.SetState(3600) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52431,10 +53299,10 @@ func (s *NotebookOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) NotebookOption() (localctx INotebookOptionContext) { localctx = NewNotebookOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 416, MDLParserRULE_notebookOption) + p.EnterRule(localctx, 420, MDLParserRULE_notebookOption) p.EnterOuterAlt(localctx, 1) { - p.SetState(3531) + p.SetState(3602) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -52442,7 +53310,7 @@ func (p *MDLParser) NotebookOption() (localctx INotebookOptionContext) { } } { - p.SetState(3532) + p.SetState(3603) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -52562,12 +53430,12 @@ func (s *NotebookPageContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) NotebookPage() (localctx INotebookPageContext) { localctx = NewNotebookPageContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 418, MDLParserRULE_notebookPage) + p.EnterRule(localctx, 422, MDLParserRULE_notebookPage) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3534) + p.SetState(3605) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -52575,10 +53443,10 @@ func (p *MDLParser) NotebookPage() (localctx INotebookPageContext) { } } { - p.SetState(3535) + p.SetState(3606) p.QualifiedName() } - p.SetState(3538) + p.SetState(3609) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52587,7 +53455,7 @@ func (p *MDLParser) NotebookPage() (localctx INotebookPageContext) { if _la == MDLParserCAPTION { { - p.SetState(3536) + p.SetState(3607) p.Match(MDLParserCAPTION) if p.HasError() { // Recognition error - abort rule @@ -52595,7 +53463,7 @@ func (p *MDLParser) NotebookPage() (localctx INotebookPageContext) { } } { - p.SetState(3537) + p.SetState(3608) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -52808,12 +53676,12 @@ func (s *CreateDatabaseConnectionStatementContext) ExitRule(listener antlr.Parse func (p *MDLParser) CreateDatabaseConnectionStatement() (localctx ICreateDatabaseConnectionStatementContext) { localctx = NewCreateDatabaseConnectionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 420, MDLParserRULE_createDatabaseConnectionStatement) + p.EnterRule(localctx, 424, MDLParserRULE_createDatabaseConnectionStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3540) + p.SetState(3611) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -52821,7 +53689,7 @@ func (p *MDLParser) CreateDatabaseConnectionStatement() (localctx ICreateDatabas } } { - p.SetState(3541) + p.SetState(3612) p.Match(MDLParserCONNECTION) if p.HasError() { // Recognition error - abort rule @@ -52829,30 +53697,30 @@ func (p *MDLParser) CreateDatabaseConnectionStatement() (localctx ICreateDatabas } } { - p.SetState(3542) + p.SetState(3613) p.QualifiedName() } - p.SetState(3544) + p.SetState(3615) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == MDLParserHOST || _la == MDLParserPORT || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&15) != 0) || _la == MDLParserTYPE { + for ok := true; ok; ok = _la == MDLParserHOST || _la == MDLParserPORT || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&15) != 0) || _la == MDLParserTYPE { { - p.SetState(3543) + p.SetState(3614) p.DatabaseConnectionOption() } - p.SetState(3546) + p.SetState(3617) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(3556) + p.SetState(3627) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52861,14 +53729,14 @@ func (p *MDLParser) CreateDatabaseConnectionStatement() (localctx ICreateDatabas if _la == MDLParserBEGIN { { - p.SetState(3548) + p.SetState(3619) p.Match(MDLParserBEGIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3552) + p.SetState(3623) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52877,11 +53745,11 @@ func (p *MDLParser) CreateDatabaseConnectionStatement() (localctx ICreateDatabas for _la == MDLParserQUERY { { - p.SetState(3549) + p.SetState(3620) p.DatabaseQuery() } - p.SetState(3554) + p.SetState(3625) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -52889,7 +53757,7 @@ func (p *MDLParser) CreateDatabaseConnectionStatement() (localctx ICreateDatabas _la = p.GetTokenStream().LA(1) } { - p.SetState(3555) + p.SetState(3626) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule @@ -53051,8 +53919,8 @@ func (s *DatabaseConnectionOptionContext) ExitRule(listener antlr.ParseTreeListe func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOptionContext) { localctx = NewDatabaseConnectionOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 422, MDLParserRULE_databaseConnectionOption) - p.SetState(3585) + p.EnterRule(localctx, 426, MDLParserRULE_databaseConnectionOption) + p.SetState(3656) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53062,7 +53930,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserTYPE: p.EnterOuterAlt(localctx, 1) { - p.SetState(3558) + p.SetState(3629) p.Match(MDLParserTYPE) if p.HasError() { // Recognition error - abort rule @@ -53070,7 +53938,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3559) + p.SetState(3630) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53081,7 +53949,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserCONNECTION: p.EnterOuterAlt(localctx, 2) { - p.SetState(3560) + p.SetState(3631) p.Match(MDLParserCONNECTION) if p.HasError() { // Recognition error - abort rule @@ -53089,14 +53957,14 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3561) + p.SetState(3632) p.Match(MDLParserSTRING_TYPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3565) + p.SetState(3636) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53105,7 +53973,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti switch p.GetTokenStream().LA(1) { case MDLParserSTRING_LITERAL: { - p.SetState(3562) + p.SetState(3633) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53115,7 +53983,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserAT: { - p.SetState(3563) + p.SetState(3634) p.Match(MDLParserAT) if p.HasError() { // Recognition error - abort rule @@ -53123,7 +53991,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3564) + p.SetState(3635) p.QualifiedName() } @@ -53135,7 +54003,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserHOST: p.EnterOuterAlt(localctx, 3) { - p.SetState(3567) + p.SetState(3638) p.Match(MDLParserHOST) if p.HasError() { // Recognition error - abort rule @@ -53143,7 +54011,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3568) + p.SetState(3639) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53154,7 +54022,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserPORT: p.EnterOuterAlt(localctx, 4) { - p.SetState(3569) + p.SetState(3640) p.Match(MDLParserPORT) if p.HasError() { // Recognition error - abort rule @@ -53162,7 +54030,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3570) + p.SetState(3641) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53173,7 +54041,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserDATABASE: p.EnterOuterAlt(localctx, 5) { - p.SetState(3571) + p.SetState(3642) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -53181,7 +54049,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3572) + p.SetState(3643) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53192,14 +54060,14 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserUSERNAME: p.EnterOuterAlt(localctx, 6) { - p.SetState(3573) + p.SetState(3644) p.Match(MDLParserUSERNAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3577) + p.SetState(3648) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53208,7 +54076,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti switch p.GetTokenStream().LA(1) { case MDLParserSTRING_LITERAL: { - p.SetState(3574) + p.SetState(3645) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53218,7 +54086,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserAT: { - p.SetState(3575) + p.SetState(3646) p.Match(MDLParserAT) if p.HasError() { // Recognition error - abort rule @@ -53226,7 +54094,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3576) + p.SetState(3647) p.QualifiedName() } @@ -53238,14 +54106,14 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserPASSWORD: p.EnterOuterAlt(localctx, 7) { - p.SetState(3579) + p.SetState(3650) p.Match(MDLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3583) + p.SetState(3654) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53254,7 +54122,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti switch p.GetTokenStream().LA(1) { case MDLParserSTRING_LITERAL: { - p.SetState(3580) + p.SetState(3651) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53264,7 +54132,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti case MDLParserAT: { - p.SetState(3581) + p.SetState(3652) p.Match(MDLParserAT) if p.HasError() { // Recognition error - abort rule @@ -53272,7 +54140,7 @@ func (p *MDLParser) DatabaseConnectionOption() (localctx IDatabaseConnectionOpti } } { - p.SetState(3582) + p.SetState(3653) p.QualifiedName() } @@ -53612,12 +54480,12 @@ func (s *DatabaseQueryContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { localctx = NewDatabaseQueryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 424, MDLParserRULE_databaseQuery) + p.EnterRule(localctx, 428, MDLParserRULE_databaseQuery) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3587) + p.SetState(3658) p.Match(MDLParserQUERY) if p.HasError() { // Recognition error - abort rule @@ -53625,11 +54493,11 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3588) + p.SetState(3659) p.IdentifierOrKeyword() } { - p.SetState(3589) + p.SetState(3660) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -53637,7 +54505,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3590) + p.SetState(3661) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserSTRING_LITERAL || _la == MDLParserDOLLAR_STRING) { @@ -53647,7 +54515,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { p.Consume() } } - p.SetState(3602) + p.SetState(3673) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53656,7 +54524,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { for _la == MDLParserPARAMETER { { - p.SetState(3591) + p.SetState(3662) p.Match(MDLParserPARAMETER) if p.HasError() { // Recognition error - abort rule @@ -53664,11 +54532,11 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3592) + p.SetState(3663) p.IdentifierOrKeyword() } { - p.SetState(3593) + p.SetState(3664) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -53676,10 +54544,10 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3594) + p.SetState(3665) p.DataType() } - p.SetState(3598) + p.SetState(3669) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53687,7 +54555,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { switch p.GetTokenStream().LA(1) { case MDLParserDEFAULT: { - p.SetState(3595) + p.SetState(3666) p.Match(MDLParserDEFAULT) if p.HasError() { // Recognition error - abort rule @@ -53695,7 +54563,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3596) + p.SetState(3667) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -53705,7 +54573,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { case MDLParserNULL: { - p.SetState(3597) + p.SetState(3668) p.Match(MDLParserNULL) if p.HasError() { // Recognition error - abort rule @@ -53718,14 +54586,14 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { default: } - p.SetState(3604) + p.SetState(3675) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(3621) + p.SetState(3692) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53734,7 +54602,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { if _la == MDLParserRETURNS { { - p.SetState(3605) + p.SetState(3676) p.Match(MDLParserRETURNS) if p.HasError() { // Recognition error - abort rule @@ -53742,10 +54610,10 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3606) + p.SetState(3677) p.QualifiedName() } - p.SetState(3619) + p.SetState(3690) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53754,7 +54622,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { if _la == MDLParserMAP { { - p.SetState(3607) + p.SetState(3678) p.Match(MDLParserMAP) if p.HasError() { // Recognition error - abort rule @@ -53762,7 +54630,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3608) + p.SetState(3679) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -53770,10 +54638,10 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3609) + p.SetState(3680) p.DatabaseQueryMapping() } - p.SetState(3614) + p.SetState(3685) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53782,7 +54650,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { for _la == MDLParserCOMMA { { - p.SetState(3610) + p.SetState(3681) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -53790,11 +54658,11 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } } { - p.SetState(3611) + p.SetState(3682) p.DatabaseQueryMapping() } - p.SetState(3616) + p.SetState(3687) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -53802,7 +54670,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3617) + p.SetState(3688) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -53814,7 +54682,7 @@ func (p *MDLParser) DatabaseQuery() (localctx IDatabaseQueryContext) { } { - p.SetState(3623) + p.SetState(3694) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -53950,14 +54818,14 @@ func (s *DatabaseQueryMappingContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) DatabaseQueryMapping() (localctx IDatabaseQueryMappingContext) { localctx = NewDatabaseQueryMappingContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 426, MDLParserRULE_databaseQueryMapping) + p.EnterRule(localctx, 430, MDLParserRULE_databaseQueryMapping) p.EnterOuterAlt(localctx, 1) { - p.SetState(3625) + p.SetState(3696) p.IdentifierOrKeyword() } { - p.SetState(3626) + p.SetState(3697) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -53965,7 +54833,7 @@ func (p *MDLParser) DatabaseQueryMapping() (localctx IDatabaseQueryMappingContex } } { - p.SetState(3627) + p.SetState(3698) p.IdentifierOrKeyword() } @@ -54132,12 +55000,12 @@ func (s *CreateConstantStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) CreateConstantStatement() (localctx ICreateConstantStatementContext) { localctx = NewCreateConstantStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 428, MDLParserRULE_createConstantStatement) + p.EnterRule(localctx, 432, MDLParserRULE_createConstantStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3629) + p.SetState(3700) p.Match(MDLParserCONSTANT) if p.HasError() { // Recognition error - abort rule @@ -54145,11 +55013,11 @@ func (p *MDLParser) CreateConstantStatement() (localctx ICreateConstantStatement } } { - p.SetState(3630) + p.SetState(3701) p.QualifiedName() } { - p.SetState(3631) + p.SetState(3702) p.Match(MDLParserTYPE) if p.HasError() { // Recognition error - abort rule @@ -54157,11 +55025,11 @@ func (p *MDLParser) CreateConstantStatement() (localctx ICreateConstantStatement } } { - p.SetState(3632) + p.SetState(3703) p.DataType() } { - p.SetState(3633) + p.SetState(3704) p.Match(MDLParserDEFAULT) if p.HasError() { // Recognition error - abort rule @@ -54169,10 +55037,10 @@ func (p *MDLParser) CreateConstantStatement() (localctx ICreateConstantStatement } } { - p.SetState(3634) + p.SetState(3705) p.Literal() } - p.SetState(3636) + p.SetState(3707) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -54181,7 +55049,7 @@ func (p *MDLParser) CreateConstantStatement() (localctx ICreateConstantStatement if _la == MDLParserCOMMENT { { - p.SetState(3635) + p.SetState(3706) p.ConstantOptions() } @@ -54310,11 +55178,11 @@ func (s *ConstantOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ConstantOptions() (localctx IConstantOptionsContext) { localctx = NewConstantOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 430, MDLParserRULE_constantOptions) + p.EnterRule(localctx, 434, MDLParserRULE_constantOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(3639) + p.SetState(3710) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -54323,11 +55191,11 @@ func (p *MDLParser) ConstantOptions() (localctx IConstantOptionsContext) { for ok := true; ok; ok = _la == MDLParserCOMMENT { { - p.SetState(3638) + p.SetState(3709) p.ConstantOption() } - p.SetState(3641) + p.SetState(3712) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -54425,10 +55293,10 @@ func (s *ConstantOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ConstantOption() (localctx IConstantOptionContext) { localctx = NewConstantOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 432, MDLParserRULE_constantOption) + p.EnterRule(localctx, 436, MDLParserRULE_constantOption) p.EnterOuterAlt(localctx, 1) { - p.SetState(3643) + p.SetState(3714) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -54436,7 +55304,7 @@ func (p *MDLParser) ConstantOption() (localctx IConstantOptionContext) { } } { - p.SetState(3644) + p.SetState(3715) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -54621,12 +55489,12 @@ func (s *CreateRestClientStatementContext) ExitRule(listener antlr.ParseTreeList func (p *MDLParser) CreateRestClientStatement() (localctx ICreateRestClientStatementContext) { localctx = NewCreateRestClientStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 434, MDLParserRULE_createRestClientStatement) + p.EnterRule(localctx, 438, MDLParserRULE_createRestClientStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3646) + p.SetState(3717) p.Match(MDLParserREST) if p.HasError() { // Recognition error - abort rule @@ -54634,7 +55502,7 @@ func (p *MDLParser) CreateRestClientStatement() (localctx ICreateRestClientState } } { - p.SetState(3647) + p.SetState(3718) p.Match(MDLParserCLIENT) if p.HasError() { // Recognition error - abort rule @@ -54642,22 +55510,22 @@ func (p *MDLParser) CreateRestClientStatement() (localctx ICreateRestClientState } } { - p.SetState(3648) + p.SetState(3719) p.QualifiedName() } { - p.SetState(3649) + p.SetState(3720) p.RestClientOptions() } { - p.SetState(3650) + p.SetState(3721) p.Match(MDLParserBEGIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3654) + p.SetState(3725) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -54666,11 +55534,11 @@ func (p *MDLParser) CreateRestClientStatement() (localctx ICreateRestClientState for _la == MDLParserOPERATION { { - p.SetState(3651) + p.SetState(3722) p.RestOperation() } - p.SetState(3656) + p.SetState(3727) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -54678,7 +55546,7 @@ func (p *MDLParser) CreateRestClientStatement() (localctx ICreateRestClientState _la = p.GetTokenStream().LA(1) } { - p.SetState(3657) + p.SetState(3728) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule @@ -54809,24 +55677,24 @@ func (s *RestClientOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestClientOptions() (localctx IRestClientOptionsContext) { localctx = NewRestClientOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 436, MDLParserRULE_restClientOptions) + p.EnterRule(localctx, 440, MDLParserRULE_restClientOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(3660) + p.SetState(3731) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = ((int64((_la-309)) & ^0x3f) == 0 && ((int64(1)<<(_la-309))&517) != 0) || _la == MDLParserCOMMENT { + for ok := true; ok; ok = ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&517) != 0) || _la == MDLParserCOMMENT { { - p.SetState(3659) + p.SetState(3730) p.RestClientOption() } - p.SetState(3662) + p.SetState(3733) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -54966,8 +55834,8 @@ func (s *RestClientOptionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { localctx = NewRestClientOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 438, MDLParserRULE_restClientOption) - p.SetState(3673) + p.EnterRule(localctx, 442, MDLParserRULE_restClientOption) + p.SetState(3744) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -54977,7 +55845,7 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { case MDLParserBASE: p.EnterOuterAlt(localctx, 1) { - p.SetState(3664) + p.SetState(3735) p.Match(MDLParserBASE) if p.HasError() { // Recognition error - abort rule @@ -54985,7 +55853,7 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { } } { - p.SetState(3665) + p.SetState(3736) p.Match(MDLParserURL) if p.HasError() { // Recognition error - abort rule @@ -54993,7 +55861,7 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { } } { - p.SetState(3666) + p.SetState(3737) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -55004,7 +55872,7 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { case MDLParserTIMEOUT: p.EnterOuterAlt(localctx, 2) { - p.SetState(3667) + p.SetState(3738) p.Match(MDLParserTIMEOUT) if p.HasError() { // Recognition error - abort rule @@ -55012,7 +55880,7 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { } } { - p.SetState(3668) + p.SetState(3739) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -55023,7 +55891,7 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { case MDLParserAUTHENTICATION: p.EnterOuterAlt(localctx, 3) { - p.SetState(3669) + p.SetState(3740) p.Match(MDLParserAUTHENTICATION) if p.HasError() { // Recognition error - abort rule @@ -55031,14 +55899,14 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { } } { - p.SetState(3670) + p.SetState(3741) p.RestAuthentication() } case MDLParserCOMMENT: p.EnterOuterAlt(localctx, 4) { - p.SetState(3671) + p.SetState(3742) p.Match(MDLParserCOMMENT) if p.HasError() { // Recognition error - abort rule @@ -55046,7 +55914,7 @@ func (p *MDLParser) RestClientOption() (localctx IRestClientOptionContext) { } } { - p.SetState(3672) + p.SetState(3743) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -55174,8 +56042,8 @@ func (s *RestAuthenticationContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { localctx = NewRestAuthenticationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 440, MDLParserRULE_restAuthentication) - p.SetState(3683) + p.EnterRule(localctx, 444, MDLParserRULE_restAuthentication) + p.SetState(3754) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -55185,7 +56053,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { case MDLParserBASIC: p.EnterOuterAlt(localctx, 1) { - p.SetState(3675) + p.SetState(3746) p.Match(MDLParserBASIC) if p.HasError() { // Recognition error - abort rule @@ -55193,7 +56061,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { } } { - p.SetState(3676) + p.SetState(3747) p.Match(MDLParserUSERNAME) if p.HasError() { // Recognition error - abort rule @@ -55201,7 +56069,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { } } { - p.SetState(3677) + p.SetState(3748) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -55209,7 +56077,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { } } { - p.SetState(3678) + p.SetState(3749) p.Match(MDLParserPASSWORD) if p.HasError() { // Recognition error - abort rule @@ -55217,7 +56085,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { } } { - p.SetState(3679) + p.SetState(3750) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -55228,7 +56096,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { case MDLParserOAUTH: p.EnterOuterAlt(localctx, 2) { - p.SetState(3680) + p.SetState(3751) p.Match(MDLParserOAUTH) if p.HasError() { // Recognition error - abort rule @@ -55236,7 +56104,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { } } { - p.SetState(3681) + p.SetState(3752) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -55247,7 +56115,7 @@ func (p *MDLParser) RestAuthentication() (localctx IRestAuthenticationContext) { case MDLParserNONE: p.EnterOuterAlt(localctx, 3) { - p.SetState(3682) + p.SetState(3753) p.Match(MDLParserNONE) if p.HasError() { // Recognition error - abort rule @@ -55399,12 +56267,12 @@ func (s *RestOperationContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestOperation() (localctx IRestOperationContext) { localctx = NewRestOperationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 442, MDLParserRULE_restOperation) + p.EnterRule(localctx, 446, MDLParserRULE_restOperation) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3685) + p.SetState(3756) p.Match(MDLParserOPERATION) if p.HasError() { // Recognition error - abort rule @@ -55412,7 +56280,7 @@ func (p *MDLParser) RestOperation() (localctx IRestOperationContext) { } } { - p.SetState(3686) + p.SetState(3757) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -55420,7 +56288,7 @@ func (p *MDLParser) RestOperation() (localctx IRestOperationContext) { } } { - p.SetState(3687) + p.SetState(3758) p.Match(MDLParserMETHOD) if p.HasError() { // Recognition error - abort rule @@ -55428,11 +56296,11 @@ func (p *MDLParser) RestOperation() (localctx IRestOperationContext) { } } { - p.SetState(3688) + p.SetState(3759) p.RestMethod() } { - p.SetState(3689) + p.SetState(3760) p.Match(MDLParserPATH) if p.HasError() { // Recognition error - abort rule @@ -55440,23 +56308,23 @@ func (p *MDLParser) RestOperation() (localctx IRestOperationContext) { } } { - p.SetState(3690) + p.SetState(3761) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3692) + p.SetState(3763) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if (int64((_la-318)) & ^0x3f) == 0 && ((int64(1)<<(_la-318))&1099511627783) != 0 { + if (int64((_la-319)) & ^0x3f) == 0 && ((int64(1)<<(_la-319))&1099511627783) != 0 { { - p.SetState(3691) + p.SetState(3762) p.RestOperationOptions() } @@ -55567,15 +56435,15 @@ func (s *RestMethodContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestMethod() (localctx IRestMethodContext) { localctx = NewRestMethodContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 444, MDLParserRULE_restMethod) + p.EnterRule(localctx, 448, MDLParserRULE_restMethod) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3694) + p.SetState(3765) _la = p.GetTokenStream().LA(1) - if !(_la == MDLParserDELETE || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&15) != 0)) { + if !(_la == MDLParserDELETE || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&15) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -55706,24 +56574,24 @@ func (s *RestOperationOptionsContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) RestOperationOptions() (localctx IRestOperationOptionsContext) { localctx = NewRestOperationOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 446, MDLParserRULE_restOperationOptions) + p.EnterRule(localctx, 450, MDLParserRULE_restOperationOptions) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(3697) + p.SetState(3768) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = ((int64((_la-318)) & ^0x3f) == 0 && ((int64(1)<<(_la-318))&1099511627783) != 0) { + for ok := true; ok; ok = ((int64((_la-319)) & ^0x3f) == 0 && ((int64(1)<<(_la-319))&1099511627783) != 0) { { - p.SetState(3696) + p.SetState(3767) p.RestOperationOption() } - p.SetState(3699) + p.SetState(3770) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -55875,8 +56743,8 @@ func (s *RestOperationOptionContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) RestOperationOption() (localctx IRestOperationOptionContext) { localctx = NewRestOperationOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 448, MDLParserRULE_restOperationOption) - p.SetState(3709) + p.EnterRule(localctx, 452, MDLParserRULE_restOperationOption) + p.SetState(3780) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -55886,7 +56754,7 @@ func (p *MDLParser) RestOperationOption() (localctx IRestOperationOptionContext) case MDLParserBODY: p.EnterOuterAlt(localctx, 1) { - p.SetState(3701) + p.SetState(3772) p.Match(MDLParserBODY) if p.HasError() { // Recognition error - abort rule @@ -55894,7 +56762,7 @@ func (p *MDLParser) RestOperationOption() (localctx IRestOperationOptionContext) } } { - p.SetState(3702) + p.SetState(3773) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -55905,7 +56773,7 @@ func (p *MDLParser) RestOperationOption() (localctx IRestOperationOptionContext) case MDLParserRESPONSE: p.EnterOuterAlt(localctx, 2) { - p.SetState(3703) + p.SetState(3774) p.Match(MDLParserRESPONSE) if p.HasError() { // Recognition error - abort rule @@ -55913,14 +56781,14 @@ func (p *MDLParser) RestOperationOption() (localctx IRestOperationOptionContext) } } { - p.SetState(3704) + p.SetState(3775) p.RestResponse() } case MDLParserPARAMETER: p.EnterOuterAlt(localctx, 3) { - p.SetState(3705) + p.SetState(3776) p.Match(MDLParserPARAMETER) if p.HasError() { // Recognition error - abort rule @@ -55928,14 +56796,14 @@ func (p *MDLParser) RestOperationOption() (localctx IRestOperationOptionContext) } } { - p.SetState(3706) + p.SetState(3777) p.RestParameter() } case MDLParserTIMEOUT: p.EnterOuterAlt(localctx, 4) { - p.SetState(3707) + p.SetState(3778) p.Match(MDLParserTIMEOUT) if p.HasError() { // Recognition error - abort rule @@ -55943,7 +56811,7 @@ func (p *MDLParser) RestOperationOption() (localctx IRestOperationOptionContext) } } { - p.SetState(3708) + p.SetState(3779) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -56063,10 +56931,10 @@ func (s *RestResponseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestResponse() (localctx IRestResponseContext) { localctx = NewRestResponseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 450, MDLParserRULE_restResponse) + p.EnterRule(localctx, 454, MDLParserRULE_restResponse) p.EnterOuterAlt(localctx, 1) { - p.SetState(3711) + p.SetState(3782) p.Match(MDLParserSTATUS) if p.HasError() { // Recognition error - abort rule @@ -56074,7 +56942,7 @@ func (p *MDLParser) RestResponse() (localctx IRestResponseContext) { } } { - p.SetState(3712) + p.SetState(3783) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -56082,7 +56950,7 @@ func (p *MDLParser) RestResponse() (localctx IRestResponseContext) { } } { - p.SetState(3713) + p.SetState(3784) p.DataType() } @@ -56218,12 +57086,12 @@ func (s *RestParameterContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) RestParameter() (localctx IRestParameterContext) { localctx = NewRestParameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 452, MDLParserRULE_restParameter) + p.EnterRule(localctx, 456, MDLParserRULE_restParameter) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3715) + p.SetState(3786) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -56231,7 +57099,7 @@ func (p *MDLParser) RestParameter() (localctx IRestParameterContext) { } } { - p.SetState(3716) + p.SetState(3787) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -56239,10 +57107,10 @@ func (p *MDLParser) RestParameter() (localctx IRestParameterContext) { } } { - p.SetState(3717) + p.SetState(3788) p.DataType() } - p.SetState(3720) + p.SetState(3791) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -56251,7 +57119,7 @@ func (p *MDLParser) RestParameter() (localctx IRestParameterContext) { if _la == MDLParserIN { { - p.SetState(3718) + p.SetState(3789) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule @@ -56259,10 +57127,10 @@ func (p *MDLParser) RestParameter() (localctx IRestParameterContext) { } } { - p.SetState(3719) + p.SetState(3790) _la = p.GetTokenStream().LA(1) - if !(_la == MDLParserHEADER || ((int64((_la-317)) & ^0x3f) == 0 && ((int64(1)<<(_la-317))&134217733) != 0)) { + if !(_la == MDLParserHEADER || ((int64((_la-318)) & ^0x3f) == 0 && ((int64(1)<<(_la-318))&134217733) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -56411,10 +57279,10 @@ func (s *CreateIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) CreateIndexStatement() (localctx ICreateIndexStatementContext) { localctx = NewCreateIndexStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 454, MDLParserRULE_createIndexStatement) + p.EnterRule(localctx, 458, MDLParserRULE_createIndexStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(3722) + p.SetState(3793) p.Match(MDLParserINDEX) if p.HasError() { // Recognition error - abort rule @@ -56422,7 +57290,7 @@ func (p *MDLParser) CreateIndexStatement() (localctx ICreateIndexStatementContex } } { - p.SetState(3723) + p.SetState(3794) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -56430,7 +57298,7 @@ func (p *MDLParser) CreateIndexStatement() (localctx ICreateIndexStatementContex } } { - p.SetState(3724) + p.SetState(3795) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -56438,11 +57306,11 @@ func (p *MDLParser) CreateIndexStatement() (localctx ICreateIndexStatementContex } } { - p.SetState(3725) + p.SetState(3796) p.QualifiedName() } { - p.SetState(3726) + p.SetState(3797) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -56450,11 +57318,11 @@ func (p *MDLParser) CreateIndexStatement() (localctx ICreateIndexStatementContex } } { - p.SetState(3727) + p.SetState(3798) p.IndexAttributeList() } { - p.SetState(3728) + p.SetState(3799) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -56649,12 +57517,12 @@ func (s *CreateODataClientStatementContext) ExitRule(listener antlr.ParseTreeLis func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientStatementContext) { localctx = NewCreateODataClientStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 456, MDLParserRULE_createODataClientStatement) + p.EnterRule(localctx, 460, MDLParserRULE_createODataClientStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3730) + p.SetState(3801) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -56662,7 +57530,7 @@ func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientSta } } { - p.SetState(3731) + p.SetState(3802) p.Match(MDLParserCLIENT) if p.HasError() { // Recognition error - abort rule @@ -56670,11 +57538,11 @@ func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientSta } } { - p.SetState(3732) + p.SetState(3803) p.QualifiedName() } { - p.SetState(3733) + p.SetState(3804) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -56682,10 +57550,10 @@ func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientSta } } { - p.SetState(3734) + p.SetState(3805) p.OdataPropertyAssignment() } - p.SetState(3739) + p.SetState(3810) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -56694,7 +57562,7 @@ func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientSta for _la == MDLParserCOMMA { { - p.SetState(3735) + p.SetState(3806) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -56702,11 +57570,11 @@ func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientSta } } { - p.SetState(3736) + p.SetState(3807) p.OdataPropertyAssignment() } - p.SetState(3741) + p.SetState(3812) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -56714,14 +57582,14 @@ func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientSta _la = p.GetTokenStream().LA(1) } { - p.SetState(3742) + p.SetState(3813) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3744) + p.SetState(3815) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -56730,7 +57598,7 @@ func (p *MDLParser) CreateODataClientStatement() (localctx ICreateODataClientSta if _la == MDLParserHEADERS { { - p.SetState(3743) + p.SetState(3814) p.OdataHeadersClause() } @@ -56976,12 +57844,12 @@ func (s *CreateODataServiceStatementContext) ExitRule(listener antlr.ParseTreeLi func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceStatementContext) { localctx = NewCreateODataServiceStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 458, MDLParserRULE_createODataServiceStatement) + p.EnterRule(localctx, 462, MDLParserRULE_createODataServiceStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3746) + p.SetState(3817) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -56989,7 +57857,7 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS } } { - p.SetState(3747) + p.SetState(3818) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -56997,11 +57865,11 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS } } { - p.SetState(3748) + p.SetState(3819) p.QualifiedName() } { - p.SetState(3749) + p.SetState(3820) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -57009,10 +57877,10 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS } } { - p.SetState(3750) + p.SetState(3821) p.OdataPropertyAssignment() } - p.SetState(3755) + p.SetState(3826) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57021,7 +57889,7 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS for _la == MDLParserCOMMA { { - p.SetState(3751) + p.SetState(3822) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -57029,11 +57897,11 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS } } { - p.SetState(3752) + p.SetState(3823) p.OdataPropertyAssignment() } - p.SetState(3757) + p.SetState(3828) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57041,14 +57909,14 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS _la = p.GetTokenStream().LA(1) } { - p.SetState(3758) + p.SetState(3829) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3760) + p.SetState(3831) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57057,12 +57925,12 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS if _la == MDLParserAUTHENTICATION { { - p.SetState(3759) + p.SetState(3830) p.OdataAuthenticationClause() } } - p.SetState(3770) + p.SetState(3841) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57071,14 +57939,14 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS if _la == MDLParserLBRACE { { - p.SetState(3762) + p.SetState(3833) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3766) + p.SetState(3837) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57087,11 +57955,11 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS for _la == MDLParserPUBLISH { { - p.SetState(3763) + p.SetState(3834) p.PublishEntityBlock() } - p.SetState(3768) + p.SetState(3839) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57099,7 +57967,7 @@ func (p *MDLParser) CreateODataServiceStatement() (localctx ICreateODataServiceS _la = p.GetTokenStream().LA(1) } { - p.SetState(3769) + p.SetState(3840) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -57231,18 +58099,18 @@ func (s *OdataPropertyValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OdataPropertyValue() (localctx IOdataPropertyValueContext) { localctx = NewOdataPropertyValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 460, MDLParserRULE_odataPropertyValue) - p.SetState(3781) + p.EnterRule(localctx, 464, MDLParserRULE_odataPropertyValue) + p.SetState(3852) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 393, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 396, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(3772) + p.SetState(3843) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -57253,7 +58121,7 @@ func (p *MDLParser) OdataPropertyValue() (localctx IOdataPropertyValueContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(3773) + p.SetState(3844) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -57264,7 +58132,7 @@ func (p *MDLParser) OdataPropertyValue() (localctx IOdataPropertyValueContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(3774) + p.SetState(3845) p.Match(MDLParserTRUE) if p.HasError() { // Recognition error - abort rule @@ -57275,7 +58143,7 @@ func (p *MDLParser) OdataPropertyValue() (localctx IOdataPropertyValueContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(3775) + p.SetState(3846) p.Match(MDLParserFALSE) if p.HasError() { // Recognition error - abort rule @@ -57286,19 +58154,19 @@ func (p *MDLParser) OdataPropertyValue() (localctx IOdataPropertyValueContext) { case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(3776) + p.SetState(3847) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3778) + p.SetState(3849) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 392, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 395, p.GetParserRuleContext()) == 1 { { - p.SetState(3777) + p.SetState(3848) p.QualifiedName() } @@ -57309,7 +58177,7 @@ func (p *MDLParser) OdataPropertyValue() (localctx IOdataPropertyValueContext) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(3780) + p.SetState(3851) p.QualifiedName() } @@ -57436,14 +58304,14 @@ func (s *OdataPropertyAssignmentContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) OdataPropertyAssignment() (localctx IOdataPropertyAssignmentContext) { localctx = NewOdataPropertyAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 462, MDLParserRULE_odataPropertyAssignment) + p.EnterRule(localctx, 466, MDLParserRULE_odataPropertyAssignment) p.EnterOuterAlt(localctx, 1) { - p.SetState(3783) + p.SetState(3854) p.IdentifierOrKeyword() } { - p.SetState(3784) + p.SetState(3855) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -57451,7 +58319,7 @@ func (p *MDLParser) OdataPropertyAssignment() (localctx IOdataPropertyAssignment } } { - p.SetState(3785) + p.SetState(3856) p.OdataPropertyValue() } @@ -57574,14 +58442,14 @@ func (s *OdataAlterAssignmentContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) OdataAlterAssignment() (localctx IOdataAlterAssignmentContext) { localctx = NewOdataAlterAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 464, MDLParserRULE_odataAlterAssignment) + p.EnterRule(localctx, 468, MDLParserRULE_odataAlterAssignment) p.EnterOuterAlt(localctx, 1) { - p.SetState(3787) + p.SetState(3858) p.IdentifierOrKeyword() } { - p.SetState(3788) + p.SetState(3859) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -57589,7 +58457,7 @@ func (p *MDLParser) OdataAlterAssignment() (localctx IOdataAlterAssignmentContex } } { - p.SetState(3789) + p.SetState(3860) p.OdataPropertyValue() } @@ -57731,12 +58599,12 @@ func (s *OdataAuthenticationClauseContext) ExitRule(listener antlr.ParseTreeList func (p *MDLParser) OdataAuthenticationClause() (localctx IOdataAuthenticationClauseContext) { localctx = NewOdataAuthenticationClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 466, MDLParserRULE_odataAuthenticationClause) + p.EnterRule(localctx, 470, MDLParserRULE_odataAuthenticationClause) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3791) + p.SetState(3862) p.Match(MDLParserAUTHENTICATION) if p.HasError() { // Recognition error - abort rule @@ -57744,10 +58612,10 @@ func (p *MDLParser) OdataAuthenticationClause() (localctx IOdataAuthenticationCl } } { - p.SetState(3792) + p.SetState(3863) p.OdataAuthType() } - p.SetState(3797) + p.SetState(3868) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57756,7 +58624,7 @@ func (p *MDLParser) OdataAuthenticationClause() (localctx IOdataAuthenticationCl for _la == MDLParserCOMMA { { - p.SetState(3793) + p.SetState(3864) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -57764,11 +58632,11 @@ func (p *MDLParser) OdataAuthenticationClause() (localctx IOdataAuthenticationCl } } { - p.SetState(3794) + p.SetState(3865) p.OdataAuthType() } - p.SetState(3799) + p.SetState(3870) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57898,8 +58766,8 @@ func (s *OdataAuthTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OdataAuthType() (localctx IOdataAuthTypeContext) { localctx = NewOdataAuthTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 468, MDLParserRULE_odataAuthType) - p.SetState(3808) + p.EnterRule(localctx, 472, MDLParserRULE_odataAuthType) + p.SetState(3879) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -57909,7 +58777,7 @@ func (p *MDLParser) OdataAuthType() (localctx IOdataAuthTypeContext) { case MDLParserBASIC: p.EnterOuterAlt(localctx, 1) { - p.SetState(3800) + p.SetState(3871) p.Match(MDLParserBASIC) if p.HasError() { // Recognition error - abort rule @@ -57920,7 +58788,7 @@ func (p *MDLParser) OdataAuthType() (localctx IOdataAuthTypeContext) { case MDLParserSESSION: p.EnterOuterAlt(localctx, 2) { - p.SetState(3801) + p.SetState(3872) p.Match(MDLParserSESSION) if p.HasError() { // Recognition error - abort rule @@ -57931,7 +58799,7 @@ func (p *MDLParser) OdataAuthType() (localctx IOdataAuthTypeContext) { case MDLParserGUEST: p.EnterOuterAlt(localctx, 3) { - p.SetState(3802) + p.SetState(3873) p.Match(MDLParserGUEST) if p.HasError() { // Recognition error - abort rule @@ -57942,19 +58810,19 @@ func (p *MDLParser) OdataAuthType() (localctx IOdataAuthTypeContext) { case MDLParserMICROFLOW: p.EnterOuterAlt(localctx, 4) { - p.SetState(3803) + p.SetState(3874) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3805) + p.SetState(3876) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 395, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 398, p.GetParserRuleContext()) == 1 { { - p.SetState(3804) + p.SetState(3875) p.QualifiedName() } @@ -57965,7 +58833,7 @@ func (p *MDLParser) OdataAuthType() (localctx IOdataAuthTypeContext) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 5) { - p.SetState(3807) + p.SetState(3878) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -58180,12 +59048,12 @@ func (s *PublishEntityBlockContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { localctx = NewPublishEntityBlockContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 470, MDLParserRULE_publishEntityBlock) + p.EnterRule(localctx, 474, MDLParserRULE_publishEntityBlock) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3810) + p.SetState(3881) p.Match(MDLParserPUBLISH) if p.HasError() { // Recognition error - abort rule @@ -58193,7 +59061,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { } } { - p.SetState(3811) + p.SetState(3882) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -58201,10 +59069,10 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { } } { - p.SetState(3812) + p.SetState(3883) p.QualifiedName() } - p.SetState(3815) + p.SetState(3886) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58213,7 +59081,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { if _la == MDLParserAS { { - p.SetState(3813) + p.SetState(3884) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -58221,7 +59089,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { } } { - p.SetState(3814) + p.SetState(3885) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -58230,7 +59098,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { } } - p.SetState(3828) + p.SetState(3899) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58239,7 +59107,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { if _la == MDLParserLPAREN { { - p.SetState(3817) + p.SetState(3888) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -58247,10 +59115,10 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { } } { - p.SetState(3818) + p.SetState(3889) p.OdataPropertyAssignment() } - p.SetState(3823) + p.SetState(3894) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58259,7 +59127,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { for _la == MDLParserCOMMA { { - p.SetState(3819) + p.SetState(3890) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -58267,11 +59135,11 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { } } { - p.SetState(3820) + p.SetState(3891) p.OdataPropertyAssignment() } - p.SetState(3825) + p.SetState(3896) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58279,7 +59147,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3826) + p.SetState(3897) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -58288,7 +59156,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { } } - p.SetState(3831) + p.SetState(3902) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58297,12 +59165,12 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { if _la == MDLParserEXPOSE { { - p.SetState(3830) + p.SetState(3901) p.ExposeClause() } } - p.SetState(3834) + p.SetState(3905) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58311,7 +59179,7 @@ func (p *MDLParser) PublishEntityBlock() (localctx IPublishEntityBlockContext) { if _la == MDLParserSEMICOLON { { - p.SetState(3833) + p.SetState(3904) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -58474,12 +59342,12 @@ func (s *ExposeClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ExposeClause() (localctx IExposeClauseContext) { localctx = NewExposeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 472, MDLParserRULE_exposeClause) + p.EnterRule(localctx, 476, MDLParserRULE_exposeClause) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3836) + p.SetState(3907) p.Match(MDLParserEXPOSE) if p.HasError() { // Recognition error - abort rule @@ -58487,14 +59355,14 @@ func (p *MDLParser) ExposeClause() (localctx IExposeClauseContext) { } } { - p.SetState(3837) + p.SetState(3908) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3847) + p.SetState(3918) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58503,7 +59371,7 @@ func (p *MDLParser) ExposeClause() (localctx IExposeClauseContext) { switch p.GetTokenStream().LA(1) { case MDLParserSTAR: { - p.SetState(3838) + p.SetState(3909) p.Match(MDLParserSTAR) if p.HasError() { // Recognition error - abort rule @@ -58513,10 +59381,10 @@ func (p *MDLParser) ExposeClause() (localctx IExposeClauseContext) { case MDLParserIDENTIFIER: { - p.SetState(3839) + p.SetState(3910) p.ExposeMember() } - p.SetState(3844) + p.SetState(3915) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58525,7 +59393,7 @@ func (p *MDLParser) ExposeClause() (localctx IExposeClauseContext) { for _la == MDLParserCOMMA { { - p.SetState(3840) + p.SetState(3911) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -58533,11 +59401,11 @@ func (p *MDLParser) ExposeClause() (localctx IExposeClauseContext) { } } { - p.SetState(3841) + p.SetState(3912) p.ExposeMember() } - p.SetState(3846) + p.SetState(3917) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58550,7 +59418,7 @@ func (p *MDLParser) ExposeClause() (localctx IExposeClauseContext) { goto errorExit } { - p.SetState(3849) + p.SetState(3920) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -58670,19 +59538,19 @@ func (s *ExposeMemberContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ExposeMember() (localctx IExposeMemberContext) { localctx = NewExposeMemberContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 474, MDLParserRULE_exposeMember) + p.EnterRule(localctx, 478, MDLParserRULE_exposeMember) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3851) + p.SetState(3922) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3854) + p.SetState(3925) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58691,7 +59559,7 @@ func (p *MDLParser) ExposeMember() (localctx IExposeMemberContext) { if _la == MDLParserAS { { - p.SetState(3852) + p.SetState(3923) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -58699,7 +59567,7 @@ func (p *MDLParser) ExposeMember() (localctx IExposeMemberContext) { } } { - p.SetState(3853) + p.SetState(3924) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -58708,7 +59576,7 @@ func (p *MDLParser) ExposeMember() (localctx IExposeMemberContext) { } } - p.SetState(3857) + p.SetState(3928) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58717,7 +59585,7 @@ func (p *MDLParser) ExposeMember() (localctx IExposeMemberContext) { if _la == MDLParserLPAREN { { - p.SetState(3856) + p.SetState(3927) p.ExposeMemberOptions() } @@ -58833,12 +59701,12 @@ func (s *ExposeMemberOptionsContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) ExposeMemberOptions() (localctx IExposeMemberOptionsContext) { localctx = NewExposeMemberOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 476, MDLParserRULE_exposeMemberOptions) + p.EnterRule(localctx, 480, MDLParserRULE_exposeMemberOptions) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3859) + p.SetState(3930) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -58846,14 +59714,14 @@ func (p *MDLParser) ExposeMemberOptions() (localctx IExposeMemberOptionsContext) } } { - p.SetState(3860) + p.SetState(3931) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3865) + p.SetState(3936) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58862,7 +59730,7 @@ func (p *MDLParser) ExposeMemberOptions() (localctx IExposeMemberOptionsContext) for _la == MDLParserCOMMA { { - p.SetState(3861) + p.SetState(3932) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -58870,7 +59738,7 @@ func (p *MDLParser) ExposeMemberOptions() (localctx IExposeMemberOptionsContext) } } { - p.SetState(3862) + p.SetState(3933) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -58878,7 +59746,7 @@ func (p *MDLParser) ExposeMemberOptions() (localctx IExposeMemberOptionsContext) } } - p.SetState(3867) + p.SetState(3938) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -58886,7 +59754,7 @@ func (p *MDLParser) ExposeMemberOptions() (localctx IExposeMemberOptionsContext) _la = p.GetTokenStream().LA(1) } { - p.SetState(3868) + p.SetState(3939) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -59132,12 +60000,12 @@ func (s *CreateExternalEntityStatementContext) ExitRule(listener antlr.ParseTree func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEntityStatementContext) { localctx = NewCreateExternalEntityStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 478, MDLParserRULE_createExternalEntityStatement) + p.EnterRule(localctx, 482, MDLParserRULE_createExternalEntityStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3870) + p.SetState(3941) p.Match(MDLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule @@ -59145,7 +60013,7 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt } } { - p.SetState(3871) + p.SetState(3942) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -59153,11 +60021,11 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt } } { - p.SetState(3872) + p.SetState(3943) p.QualifiedName() } { - p.SetState(3873) + p.SetState(3944) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -59165,7 +60033,7 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt } } { - p.SetState(3874) + p.SetState(3945) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -59173,7 +60041,7 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt } } { - p.SetState(3875) + p.SetState(3946) p.Match(MDLParserCLIENT) if p.HasError() { // Recognition error - abort rule @@ -59181,11 +60049,11 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt } } { - p.SetState(3876) + p.SetState(3947) p.QualifiedName() } { - p.SetState(3877) + p.SetState(3948) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -59193,10 +60061,10 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt } } { - p.SetState(3878) + p.SetState(3949) p.OdataPropertyAssignment() } - p.SetState(3883) + p.SetState(3954) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -59205,7 +60073,7 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt for _la == MDLParserCOMMA { { - p.SetState(3879) + p.SetState(3950) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -59213,11 +60081,11 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt } } { - p.SetState(3880) + p.SetState(3951) p.OdataPropertyAssignment() } - p.SetState(3885) + p.SetState(3956) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -59225,14 +60093,14 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt _la = p.GetTokenStream().LA(1) } { - p.SetState(3886) + p.SetState(3957) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3892) + p.SetState(3963) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -59241,29 +60109,29 @@ func (p *MDLParser) CreateExternalEntityStatement() (localctx ICreateExternalEnt if _la == MDLParserLPAREN { { - p.SetState(3887) + p.SetState(3958) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3889) + p.SetState(3960) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&12681767114768388) != 0) || ((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&18084767253659649) != 0) || ((int64((_la-133)) & ^0x3f) == 0 && ((int64(1)<<(_la-133))&2819253375860736011) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&549772630787) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0) || ((int64((_la-471)) & ^0x3f) == 0 && ((int64(1)<<(_la-471))&10241) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&12681767114768388) != 0) || ((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&18084767253659649) != 0) || ((int64((_la-133)) & ^0x3f) == 0 && ((int64(1)<<(_la-133))&2819253375860736011) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&549772630787) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0) || ((int64((_la-492)) & ^0x3f) == 0 && ((int64(1)<<(_la-492))&10241) != 0) { { - p.SetState(3888) + p.SetState(3959) p.AttributeDefinitionList() } } { - p.SetState(3891) + p.SetState(3962) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -59423,34 +60291,34 @@ func (s *CreateNavigationStatementContext) ExitRule(listener antlr.ParseTreeList func (p *MDLParser) CreateNavigationStatement() (localctx ICreateNavigationStatementContext) { localctx = NewCreateNavigationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 480, MDLParserRULE_createNavigationStatement) + p.EnterRule(localctx, 484, MDLParserRULE_createNavigationStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3894) + p.SetState(3965) p.Match(MDLParserNAVIGATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3897) + p.SetState(3968) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 410, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 413, p.GetParserRuleContext()) { case 1: { - p.SetState(3895) + p.SetState(3966) p.QualifiedName() } case 2: { - p.SetState(3896) + p.SetState(3967) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -59461,20 +60329,20 @@ func (p *MDLParser) CreateNavigationStatement() (localctx ICreateNavigationState case antlr.ATNInvalidAltNumber: goto errorExit } - p.SetState(3902) + p.SetState(3973) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - for _la == MDLParserNOT || ((int64((_la-362)) & ^0x3f) == 0 && ((int64(1)<<(_la-362))&13) != 0) { + for _la == MDLParserNOT || ((int64((_la-363)) & ^0x3f) == 0 && ((int64(1)<<(_la-363))&13) != 0) { { - p.SetState(3899) + p.SetState(3970) p.NavigationClause() } - p.SetState(3904) + p.SetState(3975) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -59630,12 +60498,12 @@ func (s *OdataHeadersClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OdataHeadersClause() (localctx IOdataHeadersClauseContext) { localctx = NewOdataHeadersClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 482, MDLParserRULE_odataHeadersClause) + p.EnterRule(localctx, 486, MDLParserRULE_odataHeadersClause) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3905) + p.SetState(3976) p.Match(MDLParserHEADERS) if p.HasError() { // Recognition error - abort rule @@ -59643,7 +60511,7 @@ func (p *MDLParser) OdataHeadersClause() (localctx IOdataHeadersClauseContext) { } } { - p.SetState(3906) + p.SetState(3977) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -59651,10 +60519,10 @@ func (p *MDLParser) OdataHeadersClause() (localctx IOdataHeadersClauseContext) { } } { - p.SetState(3907) + p.SetState(3978) p.OdataHeaderEntry() } - p.SetState(3912) + p.SetState(3983) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -59663,7 +60531,7 @@ func (p *MDLParser) OdataHeadersClause() (localctx IOdataHeadersClauseContext) { for _la == MDLParserCOMMA { { - p.SetState(3908) + p.SetState(3979) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -59671,11 +60539,11 @@ func (p *MDLParser) OdataHeadersClause() (localctx IOdataHeadersClauseContext) { } } { - p.SetState(3909) + p.SetState(3980) p.OdataHeaderEntry() } - p.SetState(3914) + p.SetState(3985) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -59683,7 +60551,7 @@ func (p *MDLParser) OdataHeadersClause() (localctx IOdataHeadersClauseContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(3915) + p.SetState(3986) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -59798,10 +60666,10 @@ func (s *OdataHeaderEntryContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OdataHeaderEntry() (localctx IOdataHeaderEntryContext) { localctx = NewOdataHeaderEntryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 484, MDLParserRULE_odataHeaderEntry) + p.EnterRule(localctx, 488, MDLParserRULE_odataHeaderEntry) p.EnterOuterAlt(localctx, 1) { - p.SetState(3917) + p.SetState(3988) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -59809,7 +60677,7 @@ func (p *MDLParser) OdataHeaderEntry() (localctx IOdataHeaderEntryContext) { } } { - p.SetState(3918) + p.SetState(3989) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -59817,7 +60685,7 @@ func (p *MDLParser) OdataHeaderEntry() (localctx IOdataHeaderEntryContext) { } } { - p.SetState(3919) + p.SetState(3990) p.OdataPropertyValue() } @@ -60049,12 +60917,12 @@ func (s *CreateBusinessEventServiceStatementContext) ExitRule(listener antlr.Par func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusinessEventServiceStatementContext) { localctx = NewCreateBusinessEventServiceStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 486, MDLParserRULE_createBusinessEventServiceStatement) + p.EnterRule(localctx, 490, MDLParserRULE_createBusinessEventServiceStatement) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3921) + p.SetState(3992) p.Match(MDLParserBUSINESS) if p.HasError() { // Recognition error - abort rule @@ -60062,7 +60930,7 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin } } { - p.SetState(3922) + p.SetState(3993) p.Match(MDLParserEVENT) if p.HasError() { // Recognition error - abort rule @@ -60070,7 +60938,7 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin } } { - p.SetState(3923) + p.SetState(3994) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -60078,11 +60946,11 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin } } { - p.SetState(3924) + p.SetState(3995) p.QualifiedName() } { - p.SetState(3925) + p.SetState(3996) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -60090,10 +60958,10 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin } } { - p.SetState(3926) + p.SetState(3997) p.OdataPropertyAssignment() } - p.SetState(3931) + p.SetState(4002) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60102,7 +60970,7 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin for _la == MDLParserCOMMA { { - p.SetState(3927) + p.SetState(3998) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -60110,11 +60978,11 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin } } { - p.SetState(3928) + p.SetState(3999) p.OdataPropertyAssignment() } - p.SetState(3933) + p.SetState(4004) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60122,7 +60990,7 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin _la = p.GetTokenStream().LA(1) } { - p.SetState(3934) + p.SetState(4005) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -60130,14 +60998,14 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin } } { - p.SetState(3935) + p.SetState(4006) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(3937) + p.SetState(4008) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60146,11 +61014,11 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin for ok := true; ok; ok = _la == MDLParserMESSAGE { { - p.SetState(3936) + p.SetState(4007) p.BusinessEventMessageDef() } - p.SetState(3939) + p.SetState(4010) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60158,7 +61026,7 @@ func (p *MDLParser) CreateBusinessEventServiceStatement() (localctx ICreateBusin _la = p.GetTokenStream().LA(1) } { - p.SetState(3941) + p.SetState(4012) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -60387,12 +61255,12 @@ func (s *BusinessEventMessageDefContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDefContext) { localctx = NewBusinessEventMessageDefContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 488, MDLParserRULE_businessEventMessageDef) + p.EnterRule(localctx, 492, MDLParserRULE_businessEventMessageDef) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(3943) + p.SetState(4014) p.Match(MDLParserMESSAGE) if p.HasError() { // Recognition error - abort rule @@ -60400,7 +61268,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef } } { - p.SetState(3944) + p.SetState(4015) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -60408,7 +61276,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef } } { - p.SetState(3945) + p.SetState(4016) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -60416,10 +61284,10 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef } } { - p.SetState(3946) + p.SetState(4017) p.BusinessEventAttrDef() } - p.SetState(3951) + p.SetState(4022) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60428,7 +61296,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef for _la == MDLParserCOMMA { { - p.SetState(3947) + p.SetState(4018) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -60436,11 +61304,11 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef } } { - p.SetState(3948) + p.SetState(4019) p.BusinessEventAttrDef() } - p.SetState(3953) + p.SetState(4024) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60448,7 +61316,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef _la = p.GetTokenStream().LA(1) } { - p.SetState(3954) + p.SetState(4025) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -60456,7 +61324,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef } } { - p.SetState(3955) + p.SetState(4026) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserPUBLISH || _la == MDLParserSUBSCRIBE) { @@ -60466,7 +61334,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef p.Consume() } } - p.SetState(3958) + p.SetState(4029) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60475,7 +61343,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef if _la == MDLParserENTITY { { - p.SetState(3956) + p.SetState(4027) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -60483,12 +61351,12 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef } } { - p.SetState(3957) + p.SetState(4028) p.QualifiedName() } } - p.SetState(3962) + p.SetState(4033) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -60497,7 +61365,7 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef if _la == MDLParserMICROFLOW { { - p.SetState(3960) + p.SetState(4031) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -60505,13 +61373,13 @@ func (p *MDLParser) BusinessEventMessageDef() (localctx IBusinessEventMessageDef } } { - p.SetState(3961) + p.SetState(4032) p.QualifiedName() } } { - p.SetState(3964) + p.SetState(4035) p.Match(MDLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule @@ -60626,10 +61494,10 @@ func (s *BusinessEventAttrDefContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) BusinessEventAttrDef() (localctx IBusinessEventAttrDefContext) { localctx = NewBusinessEventAttrDefContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 490, MDLParserRULE_businessEventAttrDef) + p.EnterRule(localctx, 494, MDLParserRULE_businessEventAttrDef) p.EnterOuterAlt(localctx, 1) { - p.SetState(3966) + p.SetState(4037) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -60637,7 +61505,7 @@ func (p *MDLParser) BusinessEventAttrDef() (localctx IBusinessEventAttrDefContex } } { - p.SetState(3967) + p.SetState(4038) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -60645,7 +61513,7 @@ func (p *MDLParser) BusinessEventAttrDef() (localctx IBusinessEventAttrDefContex } } { - p.SetState(3968) + p.SetState(4039) p.DataType() } @@ -60662,93 +61530,97 @@ errorExit: goto errorExit // Trick to prevent compiler error if the label is not used } -// IAlterSettingsClauseContext is an interface to support dynamic dispatch. -type IAlterSettingsClauseContext interface { +// ICreateWorkflowStatementContext is an interface to support dynamic dispatch. +type ICreateWorkflowStatementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures - SettingsSection() ISettingsSectionContext - AllSettingsAssignment() []ISettingsAssignmentContext - SettingsAssignment(i int) ISettingsAssignmentContext - AllCOMMA() []antlr.TerminalNode - COMMA(i int) antlr.TerminalNode - CONSTANT() antlr.TerminalNode + AllWORKFLOW() []antlr.TerminalNode + WORKFLOW(i int) antlr.TerminalNode + AllQualifiedName() []IQualifiedNameContext + QualifiedName(i int) IQualifiedNameContext + BEGIN() antlr.TerminalNode + WorkflowBody() IWorkflowBodyContext + END() antlr.TerminalNode + PARAMETER() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + COLON() antlr.TerminalNode + DISPLAY() antlr.TerminalNode AllSTRING_LITERAL() []antlr.TerminalNode STRING_LITERAL(i int) antlr.TerminalNode - VALUE() antlr.TerminalNode - SettingsValue() ISettingsValueContext - IN() antlr.TerminalNode - CONFIGURATION() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + EXPORT() antlr.TerminalNode + LEVEL() antlr.TerminalNode + OVERVIEW() antlr.TerminalNode + PAGE() antlr.TerminalNode + DUE() antlr.TerminalNode + DATE_TYPE() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + SLASH() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + API() antlr.TerminalNode - // IsAlterSettingsClauseContext differentiates from other interfaces. - IsAlterSettingsClauseContext() + // IsCreateWorkflowStatementContext differentiates from other interfaces. + IsCreateWorkflowStatementContext() } -type AlterSettingsClauseContext struct { +type CreateWorkflowStatementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } -func NewEmptyAlterSettingsClauseContext() *AlterSettingsClauseContext { - var p = new(AlterSettingsClauseContext) +func NewEmptyCreateWorkflowStatementContext() *CreateWorkflowStatementContext { + var p = new(CreateWorkflowStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_alterSettingsClause + p.RuleIndex = MDLParserRULE_createWorkflowStatement return p } -func InitEmptyAlterSettingsClauseContext(p *AlterSettingsClauseContext) { +func InitEmptyCreateWorkflowStatementContext(p *CreateWorkflowStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_alterSettingsClause + p.RuleIndex = MDLParserRULE_createWorkflowStatement } -func (*AlterSettingsClauseContext) IsAlterSettingsClauseContext() {} +func (*CreateWorkflowStatementContext) IsCreateWorkflowStatementContext() {} -func NewAlterSettingsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterSettingsClauseContext { - var p = new(AlterSettingsClauseContext) +func NewCreateWorkflowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateWorkflowStatementContext { + var p = new(CreateWorkflowStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = MDLParserRULE_alterSettingsClause + p.RuleIndex = MDLParserRULE_createWorkflowStatement return p } -func (s *AlterSettingsClauseContext) GetParser() antlr.Parser { return s.parser } - -func (s *AlterSettingsClauseContext) SettingsSection() ISettingsSectionContext { - var t antlr.RuleContext - for _, ctx := range s.GetChildren() { - if _, ok := ctx.(ISettingsSectionContext); ok { - t = ctx.(antlr.RuleContext) - break - } - } +func (s *CreateWorkflowStatementContext) GetParser() antlr.Parser { return s.parser } - if t == nil { - return nil - } +func (s *CreateWorkflowStatementContext) AllWORKFLOW() []antlr.TerminalNode { + return s.GetTokens(MDLParserWORKFLOW) +} - return t.(ISettingsSectionContext) +func (s *CreateWorkflowStatementContext) WORKFLOW(i int) antlr.TerminalNode { + return s.GetToken(MDLParserWORKFLOW, i) } -func (s *AlterSettingsClauseContext) AllSettingsAssignment() []ISettingsAssignmentContext { +func (s *CreateWorkflowStatementContext) AllQualifiedName() []IQualifiedNameContext { children := s.GetChildren() len := 0 for _, ctx := range children { - if _, ok := ctx.(ISettingsAssignmentContext); ok { + if _, ok := ctx.(IQualifiedNameContext); ok { len++ } } - tst := make([]ISettingsAssignmentContext, len) + tst := make([]IQualifiedNameContext, len) i := 0 for _, ctx := range children { - if t, ok := ctx.(ISettingsAssignmentContext); ok { - tst[i] = t.(ISettingsAssignmentContext) + if t, ok := ctx.(IQualifiedNameContext); ok { + tst[i] = t.(IQualifiedNameContext) i++ } } @@ -60756,11 +61628,11 @@ func (s *AlterSettingsClauseContext) AllSettingsAssignment() []ISettingsAssignme return tst } -func (s *AlterSettingsClauseContext) SettingsAssignment(i int) ISettingsAssignmentContext { +func (s *CreateWorkflowStatementContext) QualifiedName(i int) IQualifiedNameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { - if _, ok := ctx.(ISettingsAssignmentContext); ok { + if _, ok := ctx.(IQualifiedNameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break @@ -60773,246 +61645,388 @@ func (s *AlterSettingsClauseContext) SettingsAssignment(i int) ISettingsAssignme return nil } - return t.(ISettingsAssignmentContext) + return t.(IQualifiedNameContext) } -func (s *AlterSettingsClauseContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(MDLParserCOMMA) +func (s *CreateWorkflowStatementContext) BEGIN() antlr.TerminalNode { + return s.GetToken(MDLParserBEGIN, 0) } -func (s *AlterSettingsClauseContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(MDLParserCOMMA, i) +func (s *CreateWorkflowStatementContext) WorkflowBody() IWorkflowBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBodyContext) } -func (s *AlterSettingsClauseContext) CONSTANT() antlr.TerminalNode { - return s.GetToken(MDLParserCONSTANT, 0) +func (s *CreateWorkflowStatementContext) END() antlr.TerminalNode { + return s.GetToken(MDLParserEND, 0) } -func (s *AlterSettingsClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { +func (s *CreateWorkflowStatementContext) PARAMETER() antlr.TerminalNode { + return s.GetToken(MDLParserPARAMETER, 0) +} + +func (s *CreateWorkflowStatementContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(MDLParserVARIABLE, 0) +} + +func (s *CreateWorkflowStatementContext) COLON() antlr.TerminalNode { + return s.GetToken(MDLParserCOLON, 0) +} + +func (s *CreateWorkflowStatementContext) DISPLAY() antlr.TerminalNode { + return s.GetToken(MDLParserDISPLAY, 0) +} + +func (s *CreateWorkflowStatementContext) AllSTRING_LITERAL() []antlr.TerminalNode { return s.GetTokens(MDLParserSTRING_LITERAL) } -func (s *AlterSettingsClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { +func (s *CreateWorkflowStatementContext) STRING_LITERAL(i int) antlr.TerminalNode { return s.GetToken(MDLParserSTRING_LITERAL, i) } -func (s *AlterSettingsClauseContext) VALUE() antlr.TerminalNode { - return s.GetToken(MDLParserVALUE, 0) +func (s *CreateWorkflowStatementContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(MDLParserDESCRIPTION, 0) } -func (s *AlterSettingsClauseContext) SettingsValue() ISettingsValueContext { - var t antlr.RuleContext - for _, ctx := range s.GetChildren() { - if _, ok := ctx.(ISettingsValueContext); ok { - t = ctx.(antlr.RuleContext) - break - } - } +func (s *CreateWorkflowStatementContext) EXPORT() antlr.TerminalNode { + return s.GetToken(MDLParserEXPORT, 0) +} - if t == nil { - return nil - } +func (s *CreateWorkflowStatementContext) LEVEL() antlr.TerminalNode { + return s.GetToken(MDLParserLEVEL, 0) +} - return t.(ISettingsValueContext) +func (s *CreateWorkflowStatementContext) OVERVIEW() antlr.TerminalNode { + return s.GetToken(MDLParserOVERVIEW, 0) } -func (s *AlterSettingsClauseContext) IN() antlr.TerminalNode { - return s.GetToken(MDLParserIN, 0) +func (s *CreateWorkflowStatementContext) PAGE() antlr.TerminalNode { + return s.GetToken(MDLParserPAGE, 0) } -func (s *AlterSettingsClauseContext) CONFIGURATION() antlr.TerminalNode { - return s.GetToken(MDLParserCONFIGURATION, 0) +func (s *CreateWorkflowStatementContext) DUE() antlr.TerminalNode { + return s.GetToken(MDLParserDUE, 0) } -func (s *AlterSettingsClauseContext) GetRuleContext() antlr.RuleContext { +func (s *CreateWorkflowStatementContext) DATE_TYPE() antlr.TerminalNode { + return s.GetToken(MDLParserDATE_TYPE, 0) +} + +func (s *CreateWorkflowStatementContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(MDLParserSEMICOLON, 0) +} + +func (s *CreateWorkflowStatementContext) SLASH() antlr.TerminalNode { + return s.GetToken(MDLParserSLASH, 0) +} + +func (s *CreateWorkflowStatementContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(MDLParserIDENTIFIER, 0) +} + +func (s *CreateWorkflowStatementContext) API() antlr.TerminalNode { + return s.GetToken(MDLParserAPI, 0) +} + +func (s *CreateWorkflowStatementContext) GetRuleContext() antlr.RuleContext { return s } -func (s *AlterSettingsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { +func (s *CreateWorkflowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } -func (s *AlterSettingsClauseContext) EnterRule(listener antlr.ParseTreeListener) { +func (s *CreateWorkflowStatementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.EnterAlterSettingsClause(s) + listenerT.EnterCreateWorkflowStatement(s) } } -func (s *AlterSettingsClauseContext) ExitRule(listener antlr.ParseTreeListener) { +func (s *CreateWorkflowStatementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(MDLParserListener); ok { - listenerT.ExitAlterSettingsClause(s) + listenerT.ExitCreateWorkflowStatement(s) } } -func (p *MDLParser) AlterSettingsClause() (localctx IAlterSettingsClauseContext) { - localctx = NewAlterSettingsClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 492, MDLParserRULE_alterSettingsClause) +func (p *MDLParser) CreateWorkflowStatement() (localctx ICreateWorkflowStatementContext) { + localctx = NewCreateWorkflowStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, MDLParserRULE_createWorkflowStatement) var _la int - p.SetState(3998) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4041) + p.Match(MDLParserWORKFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4042) + p.QualifiedName() + } + p.SetState(4047) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } + _la = p.GetTokenStream().LA(1) - switch p.GetTokenStream().LA(1) { - case MDLParserWORKFLOWS, MDLParserIDENTIFIER: - p.EnterOuterAlt(localctx, 1) + if _la == MDLParserPARAMETER { { - p.SetState(3970) - p.SettingsSection() + p.SetState(4043) + p.Match(MDLParserPARAMETER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } } { - p.SetState(3971) - p.SettingsAssignment() + p.SetState(4044) + p.Match(MDLParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } } - p.SetState(3976) - p.GetErrorHandler().Sync(p) - if p.HasError() { - goto errorExit + { + p.SetState(4045) + p.Match(MDLParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4046) + p.QualifiedName() } - _la = p.GetTokenStream().LA(1) - for _la == MDLParserCOMMA { - { - p.SetState(3972) - p.Match(MDLParserCOMMA) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(3973) - p.SettingsAssignment() - } + } + p.SetState(4051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) - p.SetState(3978) - p.GetErrorHandler().Sync(p) + if _la == MDLParserDISPLAY { + { + p.SetState(4049) + p.Match(MDLParserDISPLAY) if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4050) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule goto errorExit } - _la = p.GetTokenStream().LA(1) } - case MDLParserCONSTANT: - p.EnterOuterAlt(localctx, 2) + } + p.SetState(4055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserDESCRIPTION { { - p.SetState(3979) - p.Match(MDLParserCONSTANT) + p.SetState(4053) + p.Match(MDLParserDESCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(3980) + p.SetState(4054) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } + + } + p.SetState(4060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserEXPORT { { - p.SetState(3981) - p.Match(MDLParserVALUE) + p.SetState(4057) + p.Match(MDLParserEXPORT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(3982) - p.SettingsValue() - } - p.SetState(3986) - p.GetErrorHandler().Sync(p) - if p.HasError() { - goto errorExit + p.SetState(4058) + p.Match(MDLParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } } - _la = p.GetTokenStream().LA(1) + { + p.SetState(4059) + _la = p.GetTokenStream().LA(1) - if _la == MDLParserIN { - { - p.SetState(3983) - p.Match(MDLParserIN) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + if !(_la == MDLParserAPI || _la == MDLParserIDENTIFIER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() } - { - p.SetState(3984) - p.Match(MDLParserCONFIGURATION) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + } + + } + p.SetState(4065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserOVERVIEW { + { + p.SetState(4062) + p.Match(MDLParserOVERVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } - { - p.SetState(3985) - p.Match(MDLParserSTRING_LITERAL) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + } + { + p.SetState(4063) + p.Match(MDLParserPAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } - + } + { + p.SetState(4064) + p.QualifiedName() } - case MDLParserCONFIGURATION: - p.EnterOuterAlt(localctx, 3) + } + p.SetState(4070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserDUE { { - p.SetState(3988) - p.Match(MDLParserCONFIGURATION) + p.SetState(4067) + p.Match(MDLParserDUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(3989) - p.Match(MDLParserSTRING_LITERAL) + p.SetState(4068) + p.Match(MDLParserDATE_TYPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(3990) - p.SettingsAssignment() + p.SetState(4069) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } } - p.SetState(3995) - p.GetErrorHandler().Sync(p) + + } + { + p.SetState(4072) + p.Match(MDLParserBEGIN) if p.HasError() { + // Recognition error - abort rule goto errorExit } - _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4073) + p.WorkflowBody() + } + { + p.SetState(4074) + p.Match(MDLParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4075) + p.Match(MDLParserWORKFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4077) + p.GetErrorHandler().Sync(p) - for _la == MDLParserCOMMA { - { - p.SetState(3991) - p.Match(MDLParserCOMMA) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(3992) - p.SettingsAssignment() + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 427, p.GetParserRuleContext()) == 1 { + { + p.SetState(4076) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } + } - p.SetState(3997) - p.GetErrorHandler().Sync(p) + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4080) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 428, p.GetParserRuleContext()) == 1 { + { + p.SetState(4079) + p.Match(MDLParserSLASH) if p.HasError() { + // Recognition error - abort rule goto errorExit } - _la = p.GetTokenStream().LA(1) } - default: - p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } else if p.HasError() { // JIM goto errorExit } @@ -61029,52 +62043,4745 @@ errorExit: goto errorExit // Trick to prevent compiler error if the label is not used } -// ISettingsSectionContext is an interface to support dynamic dispatch. -type ISettingsSectionContext interface { +// IWorkflowBodyContext is an interface to support dynamic dispatch. +type IWorkflowBodyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures - IDENTIFIER() antlr.TerminalNode - WORKFLOWS() antlr.TerminalNode + AllWorkflowActivityStmt() []IWorkflowActivityStmtContext + WorkflowActivityStmt(i int) IWorkflowActivityStmtContext - // IsSettingsSectionContext differentiates from other interfaces. - IsSettingsSectionContext() + // IsWorkflowBodyContext differentiates from other interfaces. + IsWorkflowBodyContext() } -type SettingsSectionContext struct { +type WorkflowBodyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } -func NewEmptySettingsSectionContext() *SettingsSectionContext { - var p = new(SettingsSectionContext) +func NewEmptyWorkflowBodyContext() *WorkflowBodyContext { + var p = new(WorkflowBodyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_settingsSection + p.RuleIndex = MDLParserRULE_workflowBody return p } -func InitEmptySettingsSectionContext(p *SettingsSectionContext) { +func InitEmptyWorkflowBodyContext(p *WorkflowBodyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = MDLParserRULE_settingsSection + p.RuleIndex = MDLParserRULE_workflowBody } -func (*SettingsSectionContext) IsSettingsSectionContext() {} +func (*WorkflowBodyContext) IsWorkflowBodyContext() {} -func NewSettingsSectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SettingsSectionContext { - var p = new(SettingsSectionContext) +func NewWorkflowBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowBodyContext { + var p = new(WorkflowBodyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = MDLParserRULE_settingsSection + p.RuleIndex = MDLParserRULE_workflowBody return p } -func (s *SettingsSectionContext) GetParser() antlr.Parser { return s.parser } +func (s *WorkflowBodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowBodyContext) AllWorkflowActivityStmt() []IWorkflowActivityStmtContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowActivityStmtContext); ok { + len++ + } + } + + tst := make([]IWorkflowActivityStmtContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowActivityStmtContext); ok { + tst[i] = t.(IWorkflowActivityStmtContext) + i++ + } + } + + return tst +} + +func (s *WorkflowBodyContext) WorkflowActivityStmt(i int) IWorkflowActivityStmtContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowActivityStmtContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowActivityStmtContext) +} + +func (s *WorkflowBodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowBodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowBody(s) + } +} + +func (s *WorkflowBodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowBody(s) + } +} + +func (p *MDLParser) WorkflowBody() (localctx IWorkflowBodyContext) { + localctx = NewWorkflowBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, MDLParserRULE_workflowBody) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MDLParserCALL || ((int64((_la-443)) & ^0x3f) == 0 && ((int64(1)<<(_la-443))&291077) != 0) { + { + p.SetState(4082) + p.WorkflowActivityStmt() + } + + p.SetState(4087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowActivityStmtContext is an interface to support dynamic dispatch. +type IWorkflowActivityStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WorkflowUserTaskStmt() IWorkflowUserTaskStmtContext + SEMICOLON() antlr.TerminalNode + WorkflowCallMicroflowStmt() IWorkflowCallMicroflowStmtContext + WorkflowCallWorkflowStmt() IWorkflowCallWorkflowStmtContext + WorkflowDecisionStmt() IWorkflowDecisionStmtContext + WorkflowParallelSplitStmt() IWorkflowParallelSplitStmtContext + WorkflowJumpToStmt() IWorkflowJumpToStmtContext + WorkflowWaitForTimerStmt() IWorkflowWaitForTimerStmtContext + WorkflowWaitForNotificationStmt() IWorkflowWaitForNotificationStmtContext + WorkflowAnnotationStmt() IWorkflowAnnotationStmtContext + + // IsWorkflowActivityStmtContext differentiates from other interfaces. + IsWorkflowActivityStmtContext() +} + +type WorkflowActivityStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowActivityStmtContext() *WorkflowActivityStmtContext { + var p = new(WorkflowActivityStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowActivityStmt + return p +} + +func InitEmptyWorkflowActivityStmtContext(p *WorkflowActivityStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowActivityStmt +} + +func (*WorkflowActivityStmtContext) IsWorkflowActivityStmtContext() {} + +func NewWorkflowActivityStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowActivityStmtContext { + var p = new(WorkflowActivityStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowActivityStmt + + return p +} + +func (s *WorkflowActivityStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowActivityStmtContext) WorkflowUserTaskStmt() IWorkflowUserTaskStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowUserTaskStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowUserTaskStmtContext) +} + +func (s *WorkflowActivityStmtContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(MDLParserSEMICOLON, 0) +} + +func (s *WorkflowActivityStmtContext) WorkflowCallMicroflowStmt() IWorkflowCallMicroflowStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowCallMicroflowStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowCallMicroflowStmtContext) +} + +func (s *WorkflowActivityStmtContext) WorkflowCallWorkflowStmt() IWorkflowCallWorkflowStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowCallWorkflowStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowCallWorkflowStmtContext) +} + +func (s *WorkflowActivityStmtContext) WorkflowDecisionStmt() IWorkflowDecisionStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowDecisionStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowDecisionStmtContext) +} + +func (s *WorkflowActivityStmtContext) WorkflowParallelSplitStmt() IWorkflowParallelSplitStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowParallelSplitStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowParallelSplitStmtContext) +} + +func (s *WorkflowActivityStmtContext) WorkflowJumpToStmt() IWorkflowJumpToStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowJumpToStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowJumpToStmtContext) +} + +func (s *WorkflowActivityStmtContext) WorkflowWaitForTimerStmt() IWorkflowWaitForTimerStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowWaitForTimerStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowWaitForTimerStmtContext) +} + +func (s *WorkflowActivityStmtContext) WorkflowWaitForNotificationStmt() IWorkflowWaitForNotificationStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowWaitForNotificationStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowWaitForNotificationStmtContext) +} + +func (s *WorkflowActivityStmtContext) WorkflowAnnotationStmt() IWorkflowAnnotationStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowAnnotationStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowAnnotationStmtContext) +} + +func (s *WorkflowActivityStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowActivityStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowActivityStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowActivityStmt(s) + } +} + +func (s *WorkflowActivityStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowActivityStmt(s) + } +} + +func (p *MDLParser) WorkflowActivityStmt() (localctx IWorkflowActivityStmtContext) { + localctx = NewWorkflowActivityStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, MDLParserRULE_workflowActivityStmt) + p.SetState(4115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 430, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4088) + p.WorkflowUserTaskStmt() + } + { + p.SetState(4089) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4091) + p.WorkflowCallMicroflowStmt() + } + { + p.SetState(4092) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4094) + p.WorkflowCallWorkflowStmt() + } + { + p.SetState(4095) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4097) + p.WorkflowDecisionStmt() + } + { + p.SetState(4098) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4100) + p.WorkflowParallelSplitStmt() + } + { + p.SetState(4101) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4103) + p.WorkflowJumpToStmt() + } + { + p.SetState(4104) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4106) + p.WorkflowWaitForTimerStmt() + } + { + p.SetState(4107) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4109) + p.WorkflowWaitForNotificationStmt() + } + { + p.SetState(4110) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4112) + p.WorkflowAnnotationStmt() + } + { + p.SetState(4113) + p.Match(MDLParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowUserTaskStmtContext is an interface to support dynamic dispatch. +type IWorkflowUserTaskStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USER() antlr.TerminalNode + TASK() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + PAGE() antlr.TerminalNode + AllQualifiedName() []IQualifiedNameContext + QualifiedName(i int) IQualifiedNameContext + AllTARGETING() []antlr.TerminalNode + TARGETING(i int) antlr.TerminalNode + MICROFLOW() antlr.TerminalNode + XPATH() antlr.TerminalNode + ENTITY() antlr.TerminalNode + DUE() antlr.TerminalNode + DATE_TYPE() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + OUTCOMES() antlr.TerminalNode + BOUNDARY() antlr.TerminalNode + EVENT() antlr.TerminalNode + AllWorkflowUserTaskOutcome() []IWorkflowUserTaskOutcomeContext + WorkflowUserTaskOutcome(i int) IWorkflowUserTaskOutcomeContext + AllWorkflowBoundaryEventClause() []IWorkflowBoundaryEventClauseContext + WorkflowBoundaryEventClause(i int) IWorkflowBoundaryEventClauseContext + MULTI() antlr.TerminalNode + + // IsWorkflowUserTaskStmtContext differentiates from other interfaces. + IsWorkflowUserTaskStmtContext() +} + +type WorkflowUserTaskStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowUserTaskStmtContext() *WorkflowUserTaskStmtContext { + var p = new(WorkflowUserTaskStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowUserTaskStmt + return p +} + +func InitEmptyWorkflowUserTaskStmtContext(p *WorkflowUserTaskStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowUserTaskStmt +} + +func (*WorkflowUserTaskStmtContext) IsWorkflowUserTaskStmtContext() {} + +func NewWorkflowUserTaskStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowUserTaskStmtContext { + var p = new(WorkflowUserTaskStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowUserTaskStmt + + return p +} + +func (s *WorkflowUserTaskStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowUserTaskStmtContext) USER() antlr.TerminalNode { + return s.GetToken(MDLParserUSER, 0) +} + +func (s *WorkflowUserTaskStmtContext) TASK() antlr.TerminalNode { + return s.GetToken(MDLParserTASK, 0) +} + +func (s *WorkflowUserTaskStmtContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(MDLParserIDENTIFIER, 0) +} + +func (s *WorkflowUserTaskStmtContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MDLParserSTRING_LITERAL) +} + +func (s *WorkflowUserTaskStmtContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, i) +} + +func (s *WorkflowUserTaskStmtContext) PAGE() antlr.TerminalNode { + return s.GetToken(MDLParserPAGE, 0) +} + +func (s *WorkflowUserTaskStmtContext) AllQualifiedName() []IQualifiedNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualifiedNameContext); ok { + len++ + } + } + + tst := make([]IQualifiedNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualifiedNameContext); ok { + tst[i] = t.(IQualifiedNameContext) + i++ + } + } + + return tst +} + +func (s *WorkflowUserTaskStmtContext) QualifiedName(i int) IQualifiedNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *WorkflowUserTaskStmtContext) AllTARGETING() []antlr.TerminalNode { + return s.GetTokens(MDLParserTARGETING) +} + +func (s *WorkflowUserTaskStmtContext) TARGETING(i int) antlr.TerminalNode { + return s.GetToken(MDLParserTARGETING, i) +} + +func (s *WorkflowUserTaskStmtContext) MICROFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserMICROFLOW, 0) +} + +func (s *WorkflowUserTaskStmtContext) XPATH() antlr.TerminalNode { + return s.GetToken(MDLParserXPATH, 0) +} + +func (s *WorkflowUserTaskStmtContext) ENTITY() antlr.TerminalNode { + return s.GetToken(MDLParserENTITY, 0) +} + +func (s *WorkflowUserTaskStmtContext) DUE() antlr.TerminalNode { + return s.GetToken(MDLParserDUE, 0) +} + +func (s *WorkflowUserTaskStmtContext) DATE_TYPE() antlr.TerminalNode { + return s.GetToken(MDLParserDATE_TYPE, 0) +} + +func (s *WorkflowUserTaskStmtContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(MDLParserDESCRIPTION, 0) +} + +func (s *WorkflowUserTaskStmtContext) OUTCOMES() antlr.TerminalNode { + return s.GetToken(MDLParserOUTCOMES, 0) +} + +func (s *WorkflowUserTaskStmtContext) BOUNDARY() antlr.TerminalNode { + return s.GetToken(MDLParserBOUNDARY, 0) +} + +func (s *WorkflowUserTaskStmtContext) EVENT() antlr.TerminalNode { + return s.GetToken(MDLParserEVENT, 0) +} + +func (s *WorkflowUserTaskStmtContext) AllWorkflowUserTaskOutcome() []IWorkflowUserTaskOutcomeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowUserTaskOutcomeContext); ok { + len++ + } + } + + tst := make([]IWorkflowUserTaskOutcomeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowUserTaskOutcomeContext); ok { + tst[i] = t.(IWorkflowUserTaskOutcomeContext) + i++ + } + } + + return tst +} + +func (s *WorkflowUserTaskStmtContext) WorkflowUserTaskOutcome(i int) IWorkflowUserTaskOutcomeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowUserTaskOutcomeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowUserTaskOutcomeContext) +} + +func (s *WorkflowUserTaskStmtContext) AllWorkflowBoundaryEventClause() []IWorkflowBoundaryEventClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + len++ + } + } + + tst := make([]IWorkflowBoundaryEventClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + tst[i] = t.(IWorkflowBoundaryEventClauseContext) + i++ + } + } + + return tst +} + +func (s *WorkflowUserTaskStmtContext) WorkflowBoundaryEventClause(i int) IWorkflowBoundaryEventClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBoundaryEventClauseContext) +} + +func (s *WorkflowUserTaskStmtContext) MULTI() antlr.TerminalNode { + return s.GetToken(MDLParserMULTI, 0) +} + +func (s *WorkflowUserTaskStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowUserTaskStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowUserTaskStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowUserTaskStmt(s) + } +} + +func (s *WorkflowUserTaskStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowUserTaskStmt(s) + } +} + +func (p *MDLParser) WorkflowUserTaskStmt() (localctx IWorkflowUserTaskStmtContext) { + localctx = NewWorkflowUserTaskStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, MDLParserRULE_workflowUserTaskStmt) + var _la int + + p.SetState(4214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MDLParserUSER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4117) + p.Match(MDLParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4118) + p.Match(MDLParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4119) + p.Match(MDLParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4120) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserPAGE { + { + p.SetState(4121) + p.Match(MDLParserPAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4122) + p.QualifiedName() + } + + } + p.SetState(4128) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 432, p.GetParserRuleContext()) == 1 { + { + p.SetState(4125) + p.Match(MDLParserTARGETING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4126) + p.Match(MDLParserMICROFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4127) + p.QualifiedName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserTARGETING { + { + p.SetState(4130) + p.Match(MDLParserTARGETING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4131) + p.Match(MDLParserXPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4132) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserENTITY { + { + p.SetState(4135) + p.Match(MDLParserENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4136) + p.QualifiedName() + } + + } + p.SetState(4142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserDUE { + { + p.SetState(4139) + p.Match(MDLParserDUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4140) + p.Match(MDLParserDATE_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4141) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserDESCRIPTION { + { + p.SetState(4144) + p.Match(MDLParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4145) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserOUTCOMES { + { + p.SetState(4148) + p.Match(MDLParserOUTCOMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MDLParserSTRING_LITERAL { + { + p.SetState(4149) + p.WorkflowUserTaskOutcome() + } + + p.SetState(4152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(4163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserBOUNDARY { + { + p.SetState(4156) + p.Match(MDLParserBOUNDARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4157) + p.Match(MDLParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-450)) & ^0x3f) == 0 && ((int64(1)<<(_la-450))&1537) != 0) { + { + p.SetState(4158) + p.WorkflowBoundaryEventClause() + } + + p.SetState(4161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case MDLParserMULTI: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4165) + p.Match(MDLParserMULTI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4166) + p.Match(MDLParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4167) + p.Match(MDLParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4168) + p.Match(MDLParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4169) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserPAGE { + { + p.SetState(4170) + p.Match(MDLParserPAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4171) + p.QualifiedName() + } + + } + p.SetState(4177) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 { + { + p.SetState(4174) + p.Match(MDLParserTARGETING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4175) + p.Match(MDLParserMICROFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4176) + p.QualifiedName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserTARGETING { + { + p.SetState(4179) + p.Match(MDLParserTARGETING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4180) + p.Match(MDLParserXPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4181) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserENTITY { + { + p.SetState(4184) + p.Match(MDLParserENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4185) + p.QualifiedName() + } + + } + p.SetState(4191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserDUE { + { + p.SetState(4188) + p.Match(MDLParserDUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4189) + p.Match(MDLParserDATE_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4190) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserDESCRIPTION { + { + p.SetState(4193) + p.Match(MDLParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4194) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserOUTCOMES { + { + p.SetState(4197) + p.Match(MDLParserOUTCOMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MDLParserSTRING_LITERAL { + { + p.SetState(4198) + p.WorkflowUserTaskOutcome() + } + + p.SetState(4201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(4212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserBOUNDARY { + { + p.SetState(4205) + p.Match(MDLParserBOUNDARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4206) + p.Match(MDLParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-450)) & ^0x3f) == 0 && ((int64(1)<<(_la-450))&1537) != 0) { + { + p.SetState(4207) + p.WorkflowBoundaryEventClause() + } + + p.SetState(4210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowBoundaryEventClauseContext is an interface to support dynamic dispatch. +type IWorkflowBoundaryEventClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTERRUPTING() antlr.TerminalNode + TIMER() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + LBRACE() antlr.TerminalNode + WorkflowBody() IWorkflowBodyContext + RBRACE() antlr.TerminalNode + NON() antlr.TerminalNode + + // IsWorkflowBoundaryEventClauseContext differentiates from other interfaces. + IsWorkflowBoundaryEventClauseContext() +} + +type WorkflowBoundaryEventClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowBoundaryEventClauseContext() *WorkflowBoundaryEventClauseContext { + var p = new(WorkflowBoundaryEventClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowBoundaryEventClause + return p +} + +func InitEmptyWorkflowBoundaryEventClauseContext(p *WorkflowBoundaryEventClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowBoundaryEventClause +} + +func (*WorkflowBoundaryEventClauseContext) IsWorkflowBoundaryEventClauseContext() {} + +func NewWorkflowBoundaryEventClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowBoundaryEventClauseContext { + var p = new(WorkflowBoundaryEventClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowBoundaryEventClause + + return p +} + +func (s *WorkflowBoundaryEventClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowBoundaryEventClauseContext) INTERRUPTING() antlr.TerminalNode { + return s.GetToken(MDLParserINTERRUPTING, 0) +} + +func (s *WorkflowBoundaryEventClauseContext) TIMER() antlr.TerminalNode { + return s.GetToken(MDLParserTIMER, 0) +} + +func (s *WorkflowBoundaryEventClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowBoundaryEventClauseContext) LBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserLBRACE, 0) +} + +func (s *WorkflowBoundaryEventClauseContext) WorkflowBody() IWorkflowBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBodyContext) +} + +func (s *WorkflowBoundaryEventClauseContext) RBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserRBRACE, 0) +} + +func (s *WorkflowBoundaryEventClauseContext) NON() antlr.TerminalNode { + return s.GetToken(MDLParserNON, 0) +} + +func (s *WorkflowBoundaryEventClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowBoundaryEventClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowBoundaryEventClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowBoundaryEventClause(s) + } +} + +func (s *WorkflowBoundaryEventClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowBoundaryEventClause(s) + } +} + +func (p *MDLParser) WorkflowBoundaryEventClause() (localctx IWorkflowBoundaryEventClauseContext) { + localctx = NewWorkflowBoundaryEventClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, MDLParserRULE_workflowBoundaryEventClause) + var _la int + + p.SetState(4249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MDLParserINTERRUPTING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4216) + p.Match(MDLParserINTERRUPTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4217) + p.Match(MDLParserTIMER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserSTRING_LITERAL { + { + p.SetState(4218) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserLBRACE { + { + p.SetState(4221) + p.Match(MDLParserLBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4222) + p.WorkflowBody() + } + { + p.SetState(4223) + p.Match(MDLParserRBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case MDLParserNON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4227) + p.Match(MDLParserNON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4228) + p.Match(MDLParserINTERRUPTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4229) + p.Match(MDLParserTIMER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserSTRING_LITERAL { + { + p.SetState(4230) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserLBRACE { + { + p.SetState(4233) + p.Match(MDLParserLBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4234) + p.WorkflowBody() + } + { + p.SetState(4235) + p.Match(MDLParserRBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case MDLParserTIMER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4239) + p.Match(MDLParserTIMER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserSTRING_LITERAL { + { + p.SetState(4240) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserLBRACE { + { + p.SetState(4243) + p.Match(MDLParserLBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4244) + p.WorkflowBody() + } + { + p.SetState(4245) + p.Match(MDLParserRBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowUserTaskOutcomeContext is an interface to support dynamic dispatch. +type IWorkflowUserTaskOutcomeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING_LITERAL() antlr.TerminalNode + LBRACE() antlr.TerminalNode + WorkflowBody() IWorkflowBodyContext + RBRACE() antlr.TerminalNode + + // IsWorkflowUserTaskOutcomeContext differentiates from other interfaces. + IsWorkflowUserTaskOutcomeContext() +} + +type WorkflowUserTaskOutcomeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowUserTaskOutcomeContext() *WorkflowUserTaskOutcomeContext { + var p = new(WorkflowUserTaskOutcomeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowUserTaskOutcome + return p +} + +func InitEmptyWorkflowUserTaskOutcomeContext(p *WorkflowUserTaskOutcomeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowUserTaskOutcome +} + +func (*WorkflowUserTaskOutcomeContext) IsWorkflowUserTaskOutcomeContext() {} + +func NewWorkflowUserTaskOutcomeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowUserTaskOutcomeContext { + var p = new(WorkflowUserTaskOutcomeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowUserTaskOutcome + + return p +} + +func (s *WorkflowUserTaskOutcomeContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowUserTaskOutcomeContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowUserTaskOutcomeContext) LBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserLBRACE, 0) +} + +func (s *WorkflowUserTaskOutcomeContext) WorkflowBody() IWorkflowBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBodyContext) +} + +func (s *WorkflowUserTaskOutcomeContext) RBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserRBRACE, 0) +} + +func (s *WorkflowUserTaskOutcomeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowUserTaskOutcomeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowUserTaskOutcomeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowUserTaskOutcome(s) + } +} + +func (s *WorkflowUserTaskOutcomeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowUserTaskOutcome(s) + } +} + +func (p *MDLParser) WorkflowUserTaskOutcome() (localctx IWorkflowUserTaskOutcomeContext) { + localctx = NewWorkflowUserTaskOutcomeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, MDLParserRULE_workflowUserTaskOutcome) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4251) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4252) + p.Match(MDLParserLBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4253) + p.WorkflowBody() + } + { + p.SetState(4254) + p.Match(MDLParserRBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowCallMicroflowStmtContext is an interface to support dynamic dispatch. +type IWorkflowCallMicroflowStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALL() antlr.TerminalNode + MICROFLOW() antlr.TerminalNode + QualifiedName() IQualifiedNameContext + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + WITH() antlr.TerminalNode + LPAREN() antlr.TerminalNode + AllWorkflowParameterMapping() []IWorkflowParameterMappingContext + WorkflowParameterMapping(i int) IWorkflowParameterMappingContext + RPAREN() antlr.TerminalNode + OUTCOMES() antlr.TerminalNode + BOUNDARY() antlr.TerminalNode + EVENT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllWorkflowConditionOutcome() []IWorkflowConditionOutcomeContext + WorkflowConditionOutcome(i int) IWorkflowConditionOutcomeContext + AllWorkflowBoundaryEventClause() []IWorkflowBoundaryEventClauseContext + WorkflowBoundaryEventClause(i int) IWorkflowBoundaryEventClauseContext + + // IsWorkflowCallMicroflowStmtContext differentiates from other interfaces. + IsWorkflowCallMicroflowStmtContext() +} + +type WorkflowCallMicroflowStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowCallMicroflowStmtContext() *WorkflowCallMicroflowStmtContext { + var p = new(WorkflowCallMicroflowStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowCallMicroflowStmt + return p +} + +func InitEmptyWorkflowCallMicroflowStmtContext(p *WorkflowCallMicroflowStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowCallMicroflowStmt +} + +func (*WorkflowCallMicroflowStmtContext) IsWorkflowCallMicroflowStmtContext() {} + +func NewWorkflowCallMicroflowStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowCallMicroflowStmtContext { + var p = new(WorkflowCallMicroflowStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowCallMicroflowStmt + + return p +} + +func (s *WorkflowCallMicroflowStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowCallMicroflowStmtContext) CALL() antlr.TerminalNode { + return s.GetToken(MDLParserCALL, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) MICROFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserMICROFLOW, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *WorkflowCallMicroflowStmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MDLParserCOMMENT, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) WITH() antlr.TerminalNode { + return s.GetToken(MDLParserWITH, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) LPAREN() antlr.TerminalNode { + return s.GetToken(MDLParserLPAREN, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) AllWorkflowParameterMapping() []IWorkflowParameterMappingContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowParameterMappingContext); ok { + len++ + } + } + + tst := make([]IWorkflowParameterMappingContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowParameterMappingContext); ok { + tst[i] = t.(IWorkflowParameterMappingContext) + i++ + } + } + + return tst +} + +func (s *WorkflowCallMicroflowStmtContext) WorkflowParameterMapping(i int) IWorkflowParameterMappingContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowParameterMappingContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowParameterMappingContext) +} + +func (s *WorkflowCallMicroflowStmtContext) RPAREN() antlr.TerminalNode { + return s.GetToken(MDLParserRPAREN, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) OUTCOMES() antlr.TerminalNode { + return s.GetToken(MDLParserOUTCOMES, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) BOUNDARY() antlr.TerminalNode { + return s.GetToken(MDLParserBOUNDARY, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) EVENT() antlr.TerminalNode { + return s.GetToken(MDLParserEVENT, 0) +} + +func (s *WorkflowCallMicroflowStmtContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MDLParserCOMMA) +} + +func (s *WorkflowCallMicroflowStmtContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MDLParserCOMMA, i) +} + +func (s *WorkflowCallMicroflowStmtContext) AllWorkflowConditionOutcome() []IWorkflowConditionOutcomeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowConditionOutcomeContext); ok { + len++ + } + } + + tst := make([]IWorkflowConditionOutcomeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowConditionOutcomeContext); ok { + tst[i] = t.(IWorkflowConditionOutcomeContext) + i++ + } + } + + return tst +} + +func (s *WorkflowCallMicroflowStmtContext) WorkflowConditionOutcome(i int) IWorkflowConditionOutcomeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowConditionOutcomeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowConditionOutcomeContext) +} + +func (s *WorkflowCallMicroflowStmtContext) AllWorkflowBoundaryEventClause() []IWorkflowBoundaryEventClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + len++ + } + } + + tst := make([]IWorkflowBoundaryEventClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + tst[i] = t.(IWorkflowBoundaryEventClauseContext) + i++ + } + } + + return tst +} + +func (s *WorkflowCallMicroflowStmtContext) WorkflowBoundaryEventClause(i int) IWorkflowBoundaryEventClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBoundaryEventClauseContext) +} + +func (s *WorkflowCallMicroflowStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowCallMicroflowStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowCallMicroflowStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowCallMicroflowStmt(s) + } +} + +func (s *WorkflowCallMicroflowStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowCallMicroflowStmt(s) + } +} + +func (p *MDLParser) WorkflowCallMicroflowStmt() (localctx IWorkflowCallMicroflowStmtContext) { + localctx = NewWorkflowCallMicroflowStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, MDLParserRULE_workflowCallMicroflowStmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4256) + p.Match(MDLParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4257) + p.Match(MDLParserMICROFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4258) + p.QualifiedName() + } + p.SetState(4261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserCOMMENT { + { + p.SetState(4259) + p.Match(MDLParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4260) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserWITH { + { + p.SetState(4263) + p.Match(MDLParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4264) + p.Match(MDLParserLPAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4265) + p.WorkflowParameterMapping() + } + p.SetState(4270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MDLParserCOMMA { + { + p.SetState(4266) + p.Match(MDLParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4267) + p.WorkflowParameterMapping() + } + + p.SetState(4272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4273) + p.Match(MDLParserRPAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserOUTCOMES { + { + p.SetState(4277) + p.Match(MDLParserOUTCOMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-290)) & ^0x3f) == 0 && ((int64(1)<<(_la-290))&7) != 0) || _la == MDLParserSTRING_LITERAL { + { + p.SetState(4278) + p.WorkflowConditionOutcome() + } + + p.SetState(4281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(4292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserBOUNDARY { + { + p.SetState(4285) + p.Match(MDLParserBOUNDARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4286) + p.Match(MDLParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-450)) & ^0x3f) == 0 && ((int64(1)<<(_la-450))&1537) != 0) { + { + p.SetState(4287) + p.WorkflowBoundaryEventClause() + } + + p.SetState(4290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowParameterMappingContext is an interface to support dynamic dispatch. +type IWorkflowParameterMappingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QualifiedName() IQualifiedNameContext + EQUALS() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsWorkflowParameterMappingContext differentiates from other interfaces. + IsWorkflowParameterMappingContext() +} + +type WorkflowParameterMappingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowParameterMappingContext() *WorkflowParameterMappingContext { + var p = new(WorkflowParameterMappingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowParameterMapping + return p +} + +func InitEmptyWorkflowParameterMappingContext(p *WorkflowParameterMappingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowParameterMapping +} + +func (*WorkflowParameterMappingContext) IsWorkflowParameterMappingContext() {} + +func NewWorkflowParameterMappingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowParameterMappingContext { + var p = new(WorkflowParameterMappingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowParameterMapping + + return p +} + +func (s *WorkflowParameterMappingContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowParameterMappingContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *WorkflowParameterMappingContext) EQUALS() antlr.TerminalNode { + return s.GetToken(MDLParserEQUALS, 0) +} + +func (s *WorkflowParameterMappingContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowParameterMappingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowParameterMappingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowParameterMappingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowParameterMapping(s) + } +} + +func (s *WorkflowParameterMappingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowParameterMapping(s) + } +} + +func (p *MDLParser) WorkflowParameterMapping() (localctx IWorkflowParameterMappingContext) { + localctx = NewWorkflowParameterMappingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, MDLParserRULE_workflowParameterMapping) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4294) + p.QualifiedName() + } + { + p.SetState(4295) + p.Match(MDLParserEQUALS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4296) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowCallWorkflowStmtContext is an interface to support dynamic dispatch. +type IWorkflowCallWorkflowStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALL() antlr.TerminalNode + WORKFLOW() antlr.TerminalNode + QualifiedName() IQualifiedNameContext + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + WITH() antlr.TerminalNode + LPAREN() antlr.TerminalNode + AllWorkflowParameterMapping() []IWorkflowParameterMappingContext + WorkflowParameterMapping(i int) IWorkflowParameterMappingContext + RPAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWorkflowCallWorkflowStmtContext differentiates from other interfaces. + IsWorkflowCallWorkflowStmtContext() +} + +type WorkflowCallWorkflowStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowCallWorkflowStmtContext() *WorkflowCallWorkflowStmtContext { + var p = new(WorkflowCallWorkflowStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowCallWorkflowStmt + return p +} + +func InitEmptyWorkflowCallWorkflowStmtContext(p *WorkflowCallWorkflowStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowCallWorkflowStmt +} + +func (*WorkflowCallWorkflowStmtContext) IsWorkflowCallWorkflowStmtContext() {} + +func NewWorkflowCallWorkflowStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowCallWorkflowStmtContext { + var p = new(WorkflowCallWorkflowStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowCallWorkflowStmt + + return p +} + +func (s *WorkflowCallWorkflowStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowCallWorkflowStmtContext) CALL() antlr.TerminalNode { + return s.GetToken(MDLParserCALL, 0) +} + +func (s *WorkflowCallWorkflowStmtContext) WORKFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserWORKFLOW, 0) +} + +func (s *WorkflowCallWorkflowStmtContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *WorkflowCallWorkflowStmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MDLParserCOMMENT, 0) +} + +func (s *WorkflowCallWorkflowStmtContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowCallWorkflowStmtContext) WITH() antlr.TerminalNode { + return s.GetToken(MDLParserWITH, 0) +} + +func (s *WorkflowCallWorkflowStmtContext) LPAREN() antlr.TerminalNode { + return s.GetToken(MDLParserLPAREN, 0) +} + +func (s *WorkflowCallWorkflowStmtContext) AllWorkflowParameterMapping() []IWorkflowParameterMappingContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowParameterMappingContext); ok { + len++ + } + } + + tst := make([]IWorkflowParameterMappingContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowParameterMappingContext); ok { + tst[i] = t.(IWorkflowParameterMappingContext) + i++ + } + } + + return tst +} + +func (s *WorkflowCallWorkflowStmtContext) WorkflowParameterMapping(i int) IWorkflowParameterMappingContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowParameterMappingContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowParameterMappingContext) +} + +func (s *WorkflowCallWorkflowStmtContext) RPAREN() antlr.TerminalNode { + return s.GetToken(MDLParserRPAREN, 0) +} + +func (s *WorkflowCallWorkflowStmtContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MDLParserCOMMA) +} + +func (s *WorkflowCallWorkflowStmtContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MDLParserCOMMA, i) +} + +func (s *WorkflowCallWorkflowStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowCallWorkflowStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowCallWorkflowStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowCallWorkflowStmt(s) + } +} + +func (s *WorkflowCallWorkflowStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowCallWorkflowStmt(s) + } +} + +func (p *MDLParser) WorkflowCallWorkflowStmt() (localctx IWorkflowCallWorkflowStmtContext) { + localctx = NewWorkflowCallWorkflowStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, MDLParserRULE_workflowCallWorkflowStmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4298) + p.Match(MDLParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4299) + p.Match(MDLParserWORKFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4300) + p.QualifiedName() + } + p.SetState(4303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserCOMMENT { + { + p.SetState(4301) + p.Match(MDLParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4302) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserWITH { + { + p.SetState(4305) + p.Match(MDLParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4306) + p.Match(MDLParserLPAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4307) + p.WorkflowParameterMapping() + } + p.SetState(4312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MDLParserCOMMA { + { + p.SetState(4308) + p.Match(MDLParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4309) + p.WorkflowParameterMapping() + } + + p.SetState(4314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4315) + p.Match(MDLParserRPAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowDecisionStmtContext is an interface to support dynamic dispatch. +type IWorkflowDecisionStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECISION() antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + COMMENT() antlr.TerminalNode + OUTCOMES() antlr.TerminalNode + AllWorkflowConditionOutcome() []IWorkflowConditionOutcomeContext + WorkflowConditionOutcome(i int) IWorkflowConditionOutcomeContext + + // IsWorkflowDecisionStmtContext differentiates from other interfaces. + IsWorkflowDecisionStmtContext() +} + +type WorkflowDecisionStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowDecisionStmtContext() *WorkflowDecisionStmtContext { + var p = new(WorkflowDecisionStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowDecisionStmt + return p +} + +func InitEmptyWorkflowDecisionStmtContext(p *WorkflowDecisionStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowDecisionStmt +} + +func (*WorkflowDecisionStmtContext) IsWorkflowDecisionStmtContext() {} + +func NewWorkflowDecisionStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowDecisionStmtContext { + var p = new(WorkflowDecisionStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowDecisionStmt + + return p +} + +func (s *WorkflowDecisionStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowDecisionStmtContext) DECISION() antlr.TerminalNode { + return s.GetToken(MDLParserDECISION, 0) +} + +func (s *WorkflowDecisionStmtContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MDLParserSTRING_LITERAL) +} + +func (s *WorkflowDecisionStmtContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, i) +} + +func (s *WorkflowDecisionStmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MDLParserCOMMENT, 0) +} + +func (s *WorkflowDecisionStmtContext) OUTCOMES() antlr.TerminalNode { + return s.GetToken(MDLParserOUTCOMES, 0) +} + +func (s *WorkflowDecisionStmtContext) AllWorkflowConditionOutcome() []IWorkflowConditionOutcomeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowConditionOutcomeContext); ok { + len++ + } + } + + tst := make([]IWorkflowConditionOutcomeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowConditionOutcomeContext); ok { + tst[i] = t.(IWorkflowConditionOutcomeContext) + i++ + } + } + + return tst +} + +func (s *WorkflowDecisionStmtContext) WorkflowConditionOutcome(i int) IWorkflowConditionOutcomeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowConditionOutcomeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowConditionOutcomeContext) +} + +func (s *WorkflowDecisionStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowDecisionStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowDecisionStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowDecisionStmt(s) + } +} + +func (s *WorkflowDecisionStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowDecisionStmt(s) + } +} + +func (p *MDLParser) WorkflowDecisionStmt() (localctx IWorkflowDecisionStmtContext) { + localctx = NewWorkflowDecisionStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, MDLParserRULE_workflowDecisionStmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4319) + p.Match(MDLParserDECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserSTRING_LITERAL { + { + p.SetState(4320) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserCOMMENT { + { + p.SetState(4323) + p.Match(MDLParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4324) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserOUTCOMES { + { + p.SetState(4327) + p.Match(MDLParserOUTCOMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-290)) & ^0x3f) == 0 && ((int64(1)<<(_la-290))&7) != 0) || _la == MDLParserSTRING_LITERAL { + { + p.SetState(4328) + p.WorkflowConditionOutcome() + } + + p.SetState(4331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowConditionOutcomeContext is an interface to support dynamic dispatch. +type IWorkflowConditionOutcomeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARROW() antlr.TerminalNode + LBRACE() antlr.TerminalNode + WorkflowBody() IWorkflowBodyContext + RBRACE() antlr.TerminalNode + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsWorkflowConditionOutcomeContext differentiates from other interfaces. + IsWorkflowConditionOutcomeContext() +} + +type WorkflowConditionOutcomeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowConditionOutcomeContext() *WorkflowConditionOutcomeContext { + var p = new(WorkflowConditionOutcomeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowConditionOutcome + return p +} + +func InitEmptyWorkflowConditionOutcomeContext(p *WorkflowConditionOutcomeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowConditionOutcome +} + +func (*WorkflowConditionOutcomeContext) IsWorkflowConditionOutcomeContext() {} + +func NewWorkflowConditionOutcomeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowConditionOutcomeContext { + var p = new(WorkflowConditionOutcomeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowConditionOutcome + + return p +} + +func (s *WorkflowConditionOutcomeContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowConditionOutcomeContext) ARROW() antlr.TerminalNode { + return s.GetToken(MDLParserARROW, 0) +} + +func (s *WorkflowConditionOutcomeContext) LBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserLBRACE, 0) +} + +func (s *WorkflowConditionOutcomeContext) WorkflowBody() IWorkflowBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBodyContext) +} + +func (s *WorkflowConditionOutcomeContext) RBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserRBRACE, 0) +} + +func (s *WorkflowConditionOutcomeContext) TRUE() antlr.TerminalNode { + return s.GetToken(MDLParserTRUE, 0) +} + +func (s *WorkflowConditionOutcomeContext) FALSE() antlr.TerminalNode { + return s.GetToken(MDLParserFALSE, 0) +} + +func (s *WorkflowConditionOutcomeContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowConditionOutcomeContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(MDLParserDEFAULT, 0) +} + +func (s *WorkflowConditionOutcomeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowConditionOutcomeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowConditionOutcomeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowConditionOutcome(s) + } +} + +func (s *WorkflowConditionOutcomeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowConditionOutcome(s) + } +} + +func (p *MDLParser) WorkflowConditionOutcome() (localctx IWorkflowConditionOutcomeContext) { + localctx = NewWorkflowConditionOutcomeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, MDLParserRULE_workflowConditionOutcome) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4335) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-290)) & ^0x3f) == 0 && ((int64(1)<<(_la-290))&7) != 0) || _la == MDLParserSTRING_LITERAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4336) + p.Match(MDLParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4337) + p.Match(MDLParserLBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4338) + p.WorkflowBody() + } + { + p.SetState(4339) + p.Match(MDLParserRBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowParallelSplitStmtContext is an interface to support dynamic dispatch. +type IWorkflowParallelSplitStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARALLEL() antlr.TerminalNode + SPLIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + AllWorkflowParallelPath() []IWorkflowParallelPathContext + WorkflowParallelPath(i int) IWorkflowParallelPathContext + + // IsWorkflowParallelSplitStmtContext differentiates from other interfaces. + IsWorkflowParallelSplitStmtContext() +} + +type WorkflowParallelSplitStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowParallelSplitStmtContext() *WorkflowParallelSplitStmtContext { + var p = new(WorkflowParallelSplitStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowParallelSplitStmt + return p +} + +func InitEmptyWorkflowParallelSplitStmtContext(p *WorkflowParallelSplitStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowParallelSplitStmt +} + +func (*WorkflowParallelSplitStmtContext) IsWorkflowParallelSplitStmtContext() {} + +func NewWorkflowParallelSplitStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowParallelSplitStmtContext { + var p = new(WorkflowParallelSplitStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowParallelSplitStmt + + return p +} + +func (s *WorkflowParallelSplitStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowParallelSplitStmtContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(MDLParserPARALLEL, 0) +} + +func (s *WorkflowParallelSplitStmtContext) SPLIT() antlr.TerminalNode { + return s.GetToken(MDLParserSPLIT, 0) +} + +func (s *WorkflowParallelSplitStmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MDLParserCOMMENT, 0) +} + +func (s *WorkflowParallelSplitStmtContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowParallelSplitStmtContext) AllWorkflowParallelPath() []IWorkflowParallelPathContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowParallelPathContext); ok { + len++ + } + } + + tst := make([]IWorkflowParallelPathContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowParallelPathContext); ok { + tst[i] = t.(IWorkflowParallelPathContext) + i++ + } + } + + return tst +} + +func (s *WorkflowParallelSplitStmtContext) WorkflowParallelPath(i int) IWorkflowParallelPathContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowParallelPathContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowParallelPathContext) +} + +func (s *WorkflowParallelSplitStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowParallelSplitStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowParallelSplitStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowParallelSplitStmt(s) + } +} + +func (s *WorkflowParallelSplitStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowParallelSplitStmt(s) + } +} + +func (p *MDLParser) WorkflowParallelSplitStmt() (localctx IWorkflowParallelSplitStmtContext) { + localctx = NewWorkflowParallelSplitStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, MDLParserRULE_workflowParallelSplitStmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4341) + p.Match(MDLParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4342) + p.Match(MDLParserSPLIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserCOMMENT { + { + p.SetState(4343) + p.Match(MDLParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4344) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == MDLParserPATH { + { + p.SetState(4347) + p.WorkflowParallelPath() + } + + p.SetState(4350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowParallelPathContext is an interface to support dynamic dispatch. +type IWorkflowParallelPathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PATH() antlr.TerminalNode + NUMBER_LITERAL() antlr.TerminalNode + LBRACE() antlr.TerminalNode + WorkflowBody() IWorkflowBodyContext + RBRACE() antlr.TerminalNode + + // IsWorkflowParallelPathContext differentiates from other interfaces. + IsWorkflowParallelPathContext() +} + +type WorkflowParallelPathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowParallelPathContext() *WorkflowParallelPathContext { + var p = new(WorkflowParallelPathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowParallelPath + return p +} + +func InitEmptyWorkflowParallelPathContext(p *WorkflowParallelPathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowParallelPath +} + +func (*WorkflowParallelPathContext) IsWorkflowParallelPathContext() {} + +func NewWorkflowParallelPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowParallelPathContext { + var p = new(WorkflowParallelPathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowParallelPath + + return p +} + +func (s *WorkflowParallelPathContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowParallelPathContext) PATH() antlr.TerminalNode { + return s.GetToken(MDLParserPATH, 0) +} + +func (s *WorkflowParallelPathContext) NUMBER_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserNUMBER_LITERAL, 0) +} + +func (s *WorkflowParallelPathContext) LBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserLBRACE, 0) +} + +func (s *WorkflowParallelPathContext) WorkflowBody() IWorkflowBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBodyContext) +} + +func (s *WorkflowParallelPathContext) RBRACE() antlr.TerminalNode { + return s.GetToken(MDLParserRBRACE, 0) +} + +func (s *WorkflowParallelPathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowParallelPathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowParallelPathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowParallelPath(s) + } +} + +func (s *WorkflowParallelPathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowParallelPath(s) + } +} + +func (p *MDLParser) WorkflowParallelPath() (localctx IWorkflowParallelPathContext) { + localctx = NewWorkflowParallelPathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, MDLParserRULE_workflowParallelPath) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4352) + p.Match(MDLParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4353) + p.Match(MDLParserNUMBER_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4354) + p.Match(MDLParserLBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4355) + p.WorkflowBody() + } + { + p.SetState(4356) + p.Match(MDLParserRBRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowJumpToStmtContext is an interface to support dynamic dispatch. +type IWorkflowJumpToStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JUMP() antlr.TerminalNode + TO() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsWorkflowJumpToStmtContext differentiates from other interfaces. + IsWorkflowJumpToStmtContext() +} + +type WorkflowJumpToStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowJumpToStmtContext() *WorkflowJumpToStmtContext { + var p = new(WorkflowJumpToStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowJumpToStmt + return p +} + +func InitEmptyWorkflowJumpToStmtContext(p *WorkflowJumpToStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowJumpToStmt +} + +func (*WorkflowJumpToStmtContext) IsWorkflowJumpToStmtContext() {} + +func NewWorkflowJumpToStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowJumpToStmtContext { + var p = new(WorkflowJumpToStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowJumpToStmt + + return p +} + +func (s *WorkflowJumpToStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowJumpToStmtContext) JUMP() antlr.TerminalNode { + return s.GetToken(MDLParserJUMP, 0) +} + +func (s *WorkflowJumpToStmtContext) TO() antlr.TerminalNode { + return s.GetToken(MDLParserTO, 0) +} + +func (s *WorkflowJumpToStmtContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(MDLParserIDENTIFIER, 0) +} + +func (s *WorkflowJumpToStmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MDLParserCOMMENT, 0) +} + +func (s *WorkflowJumpToStmtContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowJumpToStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowJumpToStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowJumpToStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowJumpToStmt(s) + } +} + +func (s *WorkflowJumpToStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowJumpToStmt(s) + } +} + +func (p *MDLParser) WorkflowJumpToStmt() (localctx IWorkflowJumpToStmtContext) { + localctx = NewWorkflowJumpToStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, MDLParserRULE_workflowJumpToStmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4358) + p.Match(MDLParserJUMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4359) + p.Match(MDLParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4360) + p.Match(MDLParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserCOMMENT { + { + p.SetState(4361) + p.Match(MDLParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4362) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowWaitForTimerStmtContext is an interface to support dynamic dispatch. +type IWorkflowWaitForTimerStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAIT() antlr.TerminalNode + FOR() antlr.TerminalNode + TIMER() antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsWorkflowWaitForTimerStmtContext differentiates from other interfaces. + IsWorkflowWaitForTimerStmtContext() +} + +type WorkflowWaitForTimerStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowWaitForTimerStmtContext() *WorkflowWaitForTimerStmtContext { + var p = new(WorkflowWaitForTimerStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowWaitForTimerStmt + return p +} + +func InitEmptyWorkflowWaitForTimerStmtContext(p *WorkflowWaitForTimerStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowWaitForTimerStmt +} + +func (*WorkflowWaitForTimerStmtContext) IsWorkflowWaitForTimerStmtContext() {} + +func NewWorkflowWaitForTimerStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowWaitForTimerStmtContext { + var p = new(WorkflowWaitForTimerStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowWaitForTimerStmt + + return p +} + +func (s *WorkflowWaitForTimerStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowWaitForTimerStmtContext) WAIT() antlr.TerminalNode { + return s.GetToken(MDLParserWAIT, 0) +} + +func (s *WorkflowWaitForTimerStmtContext) FOR() antlr.TerminalNode { + return s.GetToken(MDLParserFOR, 0) +} + +func (s *WorkflowWaitForTimerStmtContext) TIMER() antlr.TerminalNode { + return s.GetToken(MDLParserTIMER, 0) +} + +func (s *WorkflowWaitForTimerStmtContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MDLParserSTRING_LITERAL) +} + +func (s *WorkflowWaitForTimerStmtContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, i) +} + +func (s *WorkflowWaitForTimerStmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MDLParserCOMMENT, 0) +} + +func (s *WorkflowWaitForTimerStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowWaitForTimerStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowWaitForTimerStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowWaitForTimerStmt(s) + } +} + +func (s *WorkflowWaitForTimerStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowWaitForTimerStmt(s) + } +} + +func (p *MDLParser) WorkflowWaitForTimerStmt() (localctx IWorkflowWaitForTimerStmtContext) { + localctx = NewWorkflowWaitForTimerStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, MDLParserRULE_workflowWaitForTimerStmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4365) + p.Match(MDLParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4366) + p.Match(MDLParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4367) + p.Match(MDLParserTIMER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserSTRING_LITERAL { + { + p.SetState(4368) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserCOMMENT { + { + p.SetState(4371) + p.Match(MDLParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4372) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowWaitForNotificationStmtContext is an interface to support dynamic dispatch. +type IWorkflowWaitForNotificationStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAIT() antlr.TerminalNode + FOR() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + BOUNDARY() antlr.TerminalNode + EVENT() antlr.TerminalNode + AllWorkflowBoundaryEventClause() []IWorkflowBoundaryEventClauseContext + WorkflowBoundaryEventClause(i int) IWorkflowBoundaryEventClauseContext + + // IsWorkflowWaitForNotificationStmtContext differentiates from other interfaces. + IsWorkflowWaitForNotificationStmtContext() +} + +type WorkflowWaitForNotificationStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowWaitForNotificationStmtContext() *WorkflowWaitForNotificationStmtContext { + var p = new(WorkflowWaitForNotificationStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowWaitForNotificationStmt + return p +} + +func InitEmptyWorkflowWaitForNotificationStmtContext(p *WorkflowWaitForNotificationStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowWaitForNotificationStmt +} + +func (*WorkflowWaitForNotificationStmtContext) IsWorkflowWaitForNotificationStmtContext() {} + +func NewWorkflowWaitForNotificationStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowWaitForNotificationStmtContext { + var p = new(WorkflowWaitForNotificationStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowWaitForNotificationStmt + + return p +} + +func (s *WorkflowWaitForNotificationStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowWaitForNotificationStmtContext) WAIT() antlr.TerminalNode { + return s.GetToken(MDLParserWAIT, 0) +} + +func (s *WorkflowWaitForNotificationStmtContext) FOR() antlr.TerminalNode { + return s.GetToken(MDLParserFOR, 0) +} + +func (s *WorkflowWaitForNotificationStmtContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(MDLParserNOTIFICATION, 0) +} + +func (s *WorkflowWaitForNotificationStmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(MDLParserCOMMENT, 0) +} + +func (s *WorkflowWaitForNotificationStmtContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowWaitForNotificationStmtContext) BOUNDARY() antlr.TerminalNode { + return s.GetToken(MDLParserBOUNDARY, 0) +} + +func (s *WorkflowWaitForNotificationStmtContext) EVENT() antlr.TerminalNode { + return s.GetToken(MDLParserEVENT, 0) +} + +func (s *WorkflowWaitForNotificationStmtContext) AllWorkflowBoundaryEventClause() []IWorkflowBoundaryEventClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + len++ + } + } + + tst := make([]IWorkflowBoundaryEventClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + tst[i] = t.(IWorkflowBoundaryEventClauseContext) + i++ + } + } + + return tst +} + +func (s *WorkflowWaitForNotificationStmtContext) WorkflowBoundaryEventClause(i int) IWorkflowBoundaryEventClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkflowBoundaryEventClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkflowBoundaryEventClauseContext) +} + +func (s *WorkflowWaitForNotificationStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowWaitForNotificationStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowWaitForNotificationStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowWaitForNotificationStmt(s) + } +} + +func (s *WorkflowWaitForNotificationStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowWaitForNotificationStmt(s) + } +} + +func (p *MDLParser) WorkflowWaitForNotificationStmt() (localctx IWorkflowWaitForNotificationStmtContext) { + localctx = NewWorkflowWaitForNotificationStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, MDLParserRULE_workflowWaitForNotificationStmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4375) + p.Match(MDLParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4376) + p.Match(MDLParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4377) + p.Match(MDLParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserCOMMENT { + { + p.SetState(4378) + p.Match(MDLParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4379) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserBOUNDARY { + { + p.SetState(4382) + p.Match(MDLParserBOUNDARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4383) + p.Match(MDLParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-450)) & ^0x3f) == 0 && ((int64(1)<<(_la-450))&1537) != 0) { + { + p.SetState(4384) + p.WorkflowBoundaryEventClause() + } + + p.SetState(4387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkflowAnnotationStmtContext is an interface to support dynamic dispatch. +type IWorkflowAnnotationStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANNOTATION() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsWorkflowAnnotationStmtContext differentiates from other interfaces. + IsWorkflowAnnotationStmtContext() +} + +type WorkflowAnnotationStmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkflowAnnotationStmtContext() *WorkflowAnnotationStmtContext { + var p = new(WorkflowAnnotationStmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowAnnotationStmt + return p +} + +func InitEmptyWorkflowAnnotationStmtContext(p *WorkflowAnnotationStmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_workflowAnnotationStmt +} + +func (*WorkflowAnnotationStmtContext) IsWorkflowAnnotationStmtContext() {} + +func NewWorkflowAnnotationStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkflowAnnotationStmtContext { + var p = new(WorkflowAnnotationStmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_workflowAnnotationStmt + + return p +} + +func (s *WorkflowAnnotationStmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkflowAnnotationStmtContext) ANNOTATION() antlr.TerminalNode { + return s.GetToken(MDLParserANNOTATION, 0) +} + +func (s *WorkflowAnnotationStmtContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, 0) +} + +func (s *WorkflowAnnotationStmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkflowAnnotationStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkflowAnnotationStmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterWorkflowAnnotationStmt(s) + } +} + +func (s *WorkflowAnnotationStmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitWorkflowAnnotationStmt(s) + } +} + +func (p *MDLParser) WorkflowAnnotationStmt() (localctx IWorkflowAnnotationStmtContext) { + localctx = NewWorkflowAnnotationStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, MDLParserRULE_workflowAnnotationStmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4391) + p.Match(MDLParserANNOTATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4392) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterSettingsClauseContext is an interface to support dynamic dispatch. +type IAlterSettingsClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SettingsSection() ISettingsSectionContext + AllSettingsAssignment() []ISettingsAssignmentContext + SettingsAssignment(i int) ISettingsAssignmentContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CONSTANT() antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + VALUE() antlr.TerminalNode + SettingsValue() ISettingsValueContext + IN() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + + // IsAlterSettingsClauseContext differentiates from other interfaces. + IsAlterSettingsClauseContext() +} + +type AlterSettingsClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterSettingsClauseContext() *AlterSettingsClauseContext { + var p = new(AlterSettingsClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_alterSettingsClause + return p +} + +func InitEmptyAlterSettingsClauseContext(p *AlterSettingsClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_alterSettingsClause +} + +func (*AlterSettingsClauseContext) IsAlterSettingsClauseContext() {} + +func NewAlterSettingsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterSettingsClauseContext { + var p = new(AlterSettingsClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_alterSettingsClause + + return p +} + +func (s *AlterSettingsClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterSettingsClauseContext) SettingsSection() ISettingsSectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISettingsSectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISettingsSectionContext) +} + +func (s *AlterSettingsClauseContext) AllSettingsAssignment() []ISettingsAssignmentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISettingsAssignmentContext); ok { + len++ + } + } + + tst := make([]ISettingsAssignmentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISettingsAssignmentContext); ok { + tst[i] = t.(ISettingsAssignmentContext) + i++ + } + } + + return tst +} + +func (s *AlterSettingsClauseContext) SettingsAssignment(i int) ISettingsAssignmentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISettingsAssignmentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISettingsAssignmentContext) +} + +func (s *AlterSettingsClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(MDLParserCOMMA) +} + +func (s *AlterSettingsClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(MDLParserCOMMA, i) +} + +func (s *AlterSettingsClauseContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(MDLParserCONSTANT, 0) +} + +func (s *AlterSettingsClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(MDLParserSTRING_LITERAL) +} + +func (s *AlterSettingsClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(MDLParserSTRING_LITERAL, i) +} + +func (s *AlterSettingsClauseContext) VALUE() antlr.TerminalNode { + return s.GetToken(MDLParserVALUE, 0) +} + +func (s *AlterSettingsClauseContext) SettingsValue() ISettingsValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISettingsValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISettingsValueContext) +} + +func (s *AlterSettingsClauseContext) IN() antlr.TerminalNode { + return s.GetToken(MDLParserIN, 0) +} + +func (s *AlterSettingsClauseContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(MDLParserCONFIGURATION, 0) +} + +func (s *AlterSettingsClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterSettingsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterSettingsClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.EnterAlterSettingsClause(s) + } +} + +func (s *AlterSettingsClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(MDLParserListener); ok { + listenerT.ExitAlterSettingsClause(s) + } +} + +func (p *MDLParser) AlterSettingsClause() (localctx IAlterSettingsClauseContext) { + localctx = NewAlterSettingsClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, MDLParserRULE_alterSettingsClause) + var _la int + + p.SetState(4422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case MDLParserWORKFLOWS, MDLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4394) + p.SettingsSection() + } + { + p.SetState(4395) + p.SettingsAssignment() + } + p.SetState(4400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MDLParserCOMMA { + { + p.SetState(4396) + p.Match(MDLParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4397) + p.SettingsAssignment() + } + + p.SetState(4402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case MDLParserCONSTANT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4403) + p.Match(MDLParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4404) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4405) + p.Match(MDLParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4406) + p.SettingsValue() + } + p.SetState(4410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == MDLParserIN { + { + p.SetState(4407) + p.Match(MDLParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4408) + p.Match(MDLParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4409) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case MDLParserCONFIGURATION: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4412) + p.Match(MDLParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4413) + p.Match(MDLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4414) + p.SettingsAssignment() + } + p.SetState(4419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == MDLParserCOMMA { + { + p.SetState(4415) + p.Match(MDLParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4416) + p.SettingsAssignment() + } + + p.SetState(4421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISettingsSectionContext is an interface to support dynamic dispatch. +type ISettingsSectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIER() antlr.TerminalNode + WORKFLOWS() antlr.TerminalNode + + // IsSettingsSectionContext differentiates from other interfaces. + IsSettingsSectionContext() +} + +type SettingsSectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySettingsSectionContext() *SettingsSectionContext { + var p = new(SettingsSectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_settingsSection + return p +} + +func InitEmptySettingsSectionContext(p *SettingsSectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = MDLParserRULE_settingsSection +} + +func (*SettingsSectionContext) IsSettingsSectionContext() {} + +func NewSettingsSectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SettingsSectionContext { + var p = new(SettingsSectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = MDLParserRULE_settingsSection + + return p +} + +func (s *SettingsSectionContext) GetParser() antlr.Parser { return s.parser } func (s *SettingsSectionContext) IDENTIFIER() antlr.TerminalNode { return s.GetToken(MDLParserIDENTIFIER, 0) @@ -61106,12 +66813,12 @@ func (s *SettingsSectionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SettingsSection() (localctx ISettingsSectionContext) { localctx = NewSettingsSectionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 494, MDLParserRULE_settingsSection) + p.EnterRule(localctx, 532, MDLParserRULE_settingsSection) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4000) + p.SetState(4424) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserWORKFLOWS || _la == MDLParserIDENTIFIER) { @@ -61229,10 +66936,10 @@ func (s *SettingsAssignmentContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SettingsAssignment() (localctx ISettingsAssignmentContext) { localctx = NewSettingsAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 496, MDLParserRULE_settingsAssignment) + p.EnterRule(localctx, 534, MDLParserRULE_settingsAssignment) p.EnterOuterAlt(localctx, 1) { - p.SetState(4002) + p.SetState(4426) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -61240,7 +66947,7 @@ func (p *MDLParser) SettingsAssignment() (localctx ISettingsAssignmentContext) { } } { - p.SetState(4003) + p.SetState(4427) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -61248,7 +66955,7 @@ func (p *MDLParser) SettingsAssignment() (localctx ISettingsAssignmentContext) { } } { - p.SetState(4004) + p.SetState(4428) p.SettingsValue() } @@ -61376,18 +67083,18 @@ func (s *SettingsValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SettingsValue() (localctx ISettingsValueContext) { localctx = NewSettingsValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 498, MDLParserRULE_settingsValue) - p.SetState(4010) + p.EnterRule(localctx, 536, MDLParserRULE_settingsValue) + p.SetState(4434) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 422, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4006) + p.SetState(4430) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -61398,7 +67105,7 @@ func (p *MDLParser) SettingsValue() (localctx ISettingsValueContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4007) + p.SetState(4431) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -61409,14 +67116,14 @@ func (p *MDLParser) SettingsValue() (localctx ISettingsValueContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4008) + p.SetState(4432) p.BooleanLiteral() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(4009) + p.SetState(4433) p.QualifiedName() } @@ -61572,39 +67279,39 @@ func (s *DqlStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DqlStatement() (localctx IDqlStatementContext) { localctx = NewDqlStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 500, MDLParserRULE_dqlStatement) - p.SetState(4016) + p.EnterRule(localctx, 538, MDLParserRULE_dqlStatement) + p.SetState(4440) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 423, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 486, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4012) + p.SetState(4436) p.ShowStatement() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4013) + p.SetState(4437) p.DescribeStatement() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4014) + p.SetState(4438) p.CatalogSelectQuery() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(4015) + p.SetState(4439) p.OqlQuery() } @@ -61681,6 +67388,7 @@ type IShowStatementContext interface { ACCESS() antlr.TerminalNode ON() antlr.TerminalNode MICROFLOW() antlr.TerminalNode + WORKFLOW() antlr.TerminalNode MATRIX() antlr.TerminalNode ODATA() antlr.TerminalNode CLIENTS() antlr.TerminalNode @@ -61954,6 +67662,10 @@ func (s *ShowStatementContext) MICROFLOW() antlr.TerminalNode { return s.GetToken(MDLParserMICROFLOW, 0) } +func (s *ShowStatementContext) WORKFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserWORKFLOW, 0) +} + func (s *ShowStatementContext) MATRIX() antlr.TerminalNode { return s.GetToken(MDLParserMATRIX, 0) } @@ -62068,20 +67780,20 @@ func (s *ShowStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { localctx = NewShowStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 502, MDLParserRULE_showStatement) + p.EnterRule(localctx, 540, MDLParserRULE_showStatement) var _la int - p.SetState(4339) + p.SetState(4768) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 476, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 539, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4018) + p.SetState(4442) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62089,7 +67801,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4019) + p.SetState(4443) p.Match(MDLParserMODULES) if p.HasError() { // Recognition error - abort rule @@ -62100,7 +67812,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4020) + p.SetState(4444) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62108,14 +67820,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4021) + p.SetState(4445) p.Match(MDLParserENTITIES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4027) + p.SetState(4451) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62124,29 +67836,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4022) + p.SetState(4446) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4025) + p.SetState(4449) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 424, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 487, p.GetParserRuleContext()) { case 1: { - p.SetState(4023) + p.SetState(4447) p.QualifiedName() } case 2: { - p.SetState(4024) + p.SetState(4448) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62163,7 +67875,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4029) + p.SetState(4453) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62171,14 +67883,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4030) + p.SetState(4454) p.Match(MDLParserASSOCIATIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4036) + p.SetState(4460) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62187,29 +67899,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4031) + p.SetState(4455) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4034) + p.SetState(4458) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 426, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 489, p.GetParserRuleContext()) { case 1: { - p.SetState(4032) + p.SetState(4456) p.QualifiedName() } case 2: { - p.SetState(4033) + p.SetState(4457) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62226,7 +67938,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(4038) + p.SetState(4462) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62234,14 +67946,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4039) + p.SetState(4463) p.Match(MDLParserMICROFLOWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4045) + p.SetState(4469) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62250,29 +67962,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4040) + p.SetState(4464) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4043) + p.SetState(4467) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 428, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 491, p.GetParserRuleContext()) { case 1: { - p.SetState(4041) + p.SetState(4465) p.QualifiedName() } case 2: { - p.SetState(4042) + p.SetState(4466) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62289,7 +68001,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(4047) + p.SetState(4471) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62297,14 +68009,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4048) + p.SetState(4472) p.Match(MDLParserNANOFLOWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4054) + p.SetState(4478) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62313,29 +68025,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4049) + p.SetState(4473) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4052) + p.SetState(4476) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 430, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 493, p.GetParserRuleContext()) { case 1: { - p.SetState(4050) + p.SetState(4474) p.QualifiedName() } case 2: { - p.SetState(4051) + p.SetState(4475) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62352,7 +68064,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(4056) + p.SetState(4480) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62360,14 +68072,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4057) + p.SetState(4481) p.Match(MDLParserWORKFLOWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4063) + p.SetState(4487) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62376,29 +68088,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4058) + p.SetState(4482) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4061) + p.SetState(4485) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 432, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 495, p.GetParserRuleContext()) { case 1: { - p.SetState(4059) + p.SetState(4483) p.QualifiedName() } case 2: { - p.SetState(4060) + p.SetState(4484) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62415,7 +68127,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(4065) + p.SetState(4489) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62423,14 +68135,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4066) + p.SetState(4490) p.Match(MDLParserPAGES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4072) + p.SetState(4496) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62439,29 +68151,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4067) + p.SetState(4491) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4070) + p.SetState(4494) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 434, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 497, p.GetParserRuleContext()) { case 1: { - p.SetState(4068) + p.SetState(4492) p.QualifiedName() } case 2: { - p.SetState(4069) + p.SetState(4493) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62478,7 +68190,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(4074) + p.SetState(4498) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62486,14 +68198,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4075) + p.SetState(4499) p.Match(MDLParserSNIPPETS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4081) + p.SetState(4505) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62502,29 +68214,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4076) + p.SetState(4500) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4079) + p.SetState(4503) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 436, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 499, p.GetParserRuleContext()) { case 1: { - p.SetState(4077) + p.SetState(4501) p.QualifiedName() } case 2: { - p.SetState(4078) + p.SetState(4502) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62541,7 +68253,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(4083) + p.SetState(4507) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62549,14 +68261,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4084) + p.SetState(4508) p.Match(MDLParserENUMERATIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4090) + p.SetState(4514) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62565,29 +68277,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4085) + p.SetState(4509) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4088) + p.SetState(4512) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 438, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 501, p.GetParserRuleContext()) { case 1: { - p.SetState(4086) + p.SetState(4510) p.QualifiedName() } case 2: { - p.SetState(4087) + p.SetState(4511) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62604,7 +68316,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(4092) + p.SetState(4516) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62612,14 +68324,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4093) + p.SetState(4517) p.Match(MDLParserCONSTANTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4099) + p.SetState(4523) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62628,29 +68340,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4094) + p.SetState(4518) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4097) + p.SetState(4521) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 503, p.GetParserRuleContext()) { case 1: { - p.SetState(4095) + p.SetState(4519) p.QualifiedName() } case 2: { - p.SetState(4096) + p.SetState(4520) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62667,7 +68379,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(4101) + p.SetState(4525) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62675,14 +68387,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4102) + p.SetState(4526) p.Match(MDLParserLAYOUTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4108) + p.SetState(4532) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62691,29 +68403,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4103) + p.SetState(4527) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4106) + p.SetState(4530) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 442, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 505, p.GetParserRuleContext()) { case 1: { - p.SetState(4104) + p.SetState(4528) p.QualifiedName() } case 2: { - p.SetState(4105) + p.SetState(4529) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62730,7 +68442,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(4110) + p.SetState(4534) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62738,14 +68450,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4111) + p.SetState(4535) p.Match(MDLParserNOTEBOOKS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4117) + p.SetState(4541) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62754,29 +68466,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4112) + p.SetState(4536) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4115) + p.SetState(4539) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 444, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 507, p.GetParserRuleContext()) { case 1: { - p.SetState(4113) + p.SetState(4537) p.QualifiedName() } case 2: { - p.SetState(4114) + p.SetState(4538) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62793,7 +68505,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(4119) + p.SetState(4543) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62801,7 +68513,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4120) + p.SetState(4544) p.Match(MDLParserJAVA) if p.HasError() { // Recognition error - abort rule @@ -62809,14 +68521,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4121) + p.SetState(4545) p.Match(MDLParserACTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4127) + p.SetState(4551) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -62825,29 +68537,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4122) + p.SetState(4546) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4125) + p.SetState(4549) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 446, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 509, p.GetParserRuleContext()) { case 1: { - p.SetState(4123) + p.SetState(4547) p.QualifiedName() } case 2: { - p.SetState(4124) + p.SetState(4548) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -62864,7 +68576,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(4129) + p.SetState(4553) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62872,7 +68584,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4130) + p.SetState(4554) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -62880,14 +68592,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4131) + p.SetState(4555) p.QualifiedName() } case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(4132) + p.SetState(4556) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62895,7 +68607,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4133) + p.SetState(4557) p.Match(MDLParserASSOCIATION) if p.HasError() { // Recognition error - abort rule @@ -62903,14 +68615,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4134) + p.SetState(4558) p.QualifiedName() } case 16: p.EnterOuterAlt(localctx, 16) { - p.SetState(4135) + p.SetState(4559) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62918,7 +68630,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4136) + p.SetState(4560) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -62926,14 +68638,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4137) + p.SetState(4561) p.QualifiedName() } case 17: p.EnterOuterAlt(localctx, 17) { - p.SetState(4138) + p.SetState(4562) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62941,7 +68653,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4139) + p.SetState(4563) p.Match(MDLParserCONNECTIONS) if p.HasError() { // Recognition error - abort rule @@ -62952,7 +68664,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 18: p.EnterOuterAlt(localctx, 18) { - p.SetState(4140) + p.SetState(4564) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62960,7 +68672,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4141) + p.SetState(4565) p.Match(MDLParserSTATUS) if p.HasError() { // Recognition error - abort rule @@ -62971,7 +68683,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 19: p.EnterOuterAlt(localctx, 19) { - p.SetState(4142) + p.SetState(4566) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62979,7 +68691,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4143) + p.SetState(4567) p.Match(MDLParserVERSION) if p.HasError() { // Recognition error - abort rule @@ -62990,7 +68702,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 20: p.EnterOuterAlt(localctx, 20) { - p.SetState(4144) + p.SetState(4568) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -62998,7 +68710,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4145) + p.SetState(4569) p.Match(MDLParserCATALOG) if p.HasError() { // Recognition error - abort rule @@ -63006,7 +68718,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4146) + p.SetState(4570) p.Match(MDLParserSTATUS) if p.HasError() { // Recognition error - abort rule @@ -63017,7 +68729,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 21: p.EnterOuterAlt(localctx, 21) { - p.SetState(4147) + p.SetState(4571) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63025,7 +68737,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4148) + p.SetState(4572) p.Match(MDLParserCATALOG) if p.HasError() { // Recognition error - abort rule @@ -63033,7 +68745,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4149) + p.SetState(4573) p.Match(MDLParserTABLES) if p.HasError() { // Recognition error - abort rule @@ -63044,7 +68756,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 22: p.EnterOuterAlt(localctx, 22) { - p.SetState(4150) + p.SetState(4574) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63052,7 +68764,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4151) + p.SetState(4575) p.Match(MDLParserCALLERS) if p.HasError() { // Recognition error - abort rule @@ -63060,7 +68772,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4152) + p.SetState(4576) p.Match(MDLParserOF) if p.HasError() { // Recognition error - abort rule @@ -63068,10 +68780,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4153) + p.SetState(4577) p.QualifiedName() } - p.SetState(4155) + p.SetState(4579) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63080,7 +68792,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserTRANSITIVE { { - p.SetState(4154) + p.SetState(4578) p.Match(MDLParserTRANSITIVE) if p.HasError() { // Recognition error - abort rule @@ -63093,7 +68805,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 23: p.EnterOuterAlt(localctx, 23) { - p.SetState(4157) + p.SetState(4581) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63101,7 +68813,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4158) + p.SetState(4582) p.Match(MDLParserCALLEES) if p.HasError() { // Recognition error - abort rule @@ -63109,7 +68821,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4159) + p.SetState(4583) p.Match(MDLParserOF) if p.HasError() { // Recognition error - abort rule @@ -63117,10 +68829,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4160) + p.SetState(4584) p.QualifiedName() } - p.SetState(4162) + p.SetState(4586) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63129,7 +68841,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserTRANSITIVE { { - p.SetState(4161) + p.SetState(4585) p.Match(MDLParserTRANSITIVE) if p.HasError() { // Recognition error - abort rule @@ -63142,7 +68854,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 24: p.EnterOuterAlt(localctx, 24) { - p.SetState(4164) + p.SetState(4588) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63150,7 +68862,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4165) + p.SetState(4589) p.Match(MDLParserREFERENCES) if p.HasError() { // Recognition error - abort rule @@ -63158,7 +68870,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4166) + p.SetState(4590) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -63166,14 +68878,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4167) + p.SetState(4591) p.QualifiedName() } case 25: p.EnterOuterAlt(localctx, 25) { - p.SetState(4168) + p.SetState(4592) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63181,7 +68893,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4169) + p.SetState(4593) p.Match(MDLParserIMPACT) if p.HasError() { // Recognition error - abort rule @@ -63189,7 +68901,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4170) + p.SetState(4594) p.Match(MDLParserOF) if p.HasError() { // Recognition error - abort rule @@ -63197,14 +68909,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4171) + p.SetState(4595) p.QualifiedName() } case 26: p.EnterOuterAlt(localctx, 26) { - p.SetState(4172) + p.SetState(4596) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63212,7 +68924,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4173) + p.SetState(4597) p.Match(MDLParserCONTEXT) if p.HasError() { // Recognition error - abort rule @@ -63220,7 +68932,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4174) + p.SetState(4598) p.Match(MDLParserOF) if p.HasError() { // Recognition error - abort rule @@ -63228,10 +68940,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4175) + p.SetState(4599) p.QualifiedName() } - p.SetState(4178) + p.SetState(4602) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63240,7 +68952,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserDEPTH { { - p.SetState(4176) + p.SetState(4600) p.Match(MDLParserDEPTH) if p.HasError() { // Recognition error - abort rule @@ -63248,7 +68960,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4177) + p.SetState(4601) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -63261,7 +68973,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 27: p.EnterOuterAlt(localctx, 27) { - p.SetState(4180) + p.SetState(4604) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63269,14 +68981,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4181) + p.SetState(4605) p.Match(MDLParserWIDGETS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4183) + p.SetState(4607) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63285,7 +68997,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserWHERE || _la == MDLParserIN { { - p.SetState(4182) + p.SetState(4606) p.ShowWidgetsFilter() } @@ -63294,7 +69006,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 28: p.EnterOuterAlt(localctx, 28) { - p.SetState(4185) + p.SetState(4609) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63302,7 +69014,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4186) + p.SetState(4610) p.Match(MDLParserPROJECT) if p.HasError() { // Recognition error - abort rule @@ -63310,7 +69022,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4187) + p.SetState(4611) p.Match(MDLParserSECURITY) if p.HasError() { // Recognition error - abort rule @@ -63321,7 +69033,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 29: p.EnterOuterAlt(localctx, 29) { - p.SetState(4188) + p.SetState(4612) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63329,7 +69041,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4189) + p.SetState(4613) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -63337,14 +69049,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4190) + p.SetState(4614) p.Match(MDLParserROLES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4196) + p.SetState(4620) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63353,29 +69065,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4191) + p.SetState(4615) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4194) + p.SetState(4618) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 452, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 515, p.GetParserRuleContext()) { case 1: { - p.SetState(4192) + p.SetState(4616) p.QualifiedName() } case 2: { - p.SetState(4193) + p.SetState(4617) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -63392,7 +69104,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 30: p.EnterOuterAlt(localctx, 30) { - p.SetState(4198) + p.SetState(4622) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63400,7 +69112,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4199) + p.SetState(4623) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -63408,7 +69120,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4200) + p.SetState(4624) p.Match(MDLParserROLES) if p.HasError() { // Recognition error - abort rule @@ -63419,7 +69131,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 31: p.EnterOuterAlt(localctx, 31) { - p.SetState(4201) + p.SetState(4625) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63427,7 +69139,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4202) + p.SetState(4626) p.Match(MDLParserDEMO) if p.HasError() { // Recognition error - abort rule @@ -63435,7 +69147,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4203) + p.SetState(4627) p.Match(MDLParserUSERS) if p.HasError() { // Recognition error - abort rule @@ -63446,7 +69158,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { case 32: p.EnterOuterAlt(localctx, 32) { - p.SetState(4204) + p.SetState(4628) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63454,7 +69166,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4205) + p.SetState(4629) p.Match(MDLParserACCESS) if p.HasError() { // Recognition error - abort rule @@ -63462,7 +69174,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4206) + p.SetState(4630) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -63470,14 +69182,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4207) + p.SetState(4631) p.QualifiedName() } case 33: p.EnterOuterAlt(localctx, 33) { - p.SetState(4208) + p.SetState(4632) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63485,7 +69197,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4209) + p.SetState(4633) p.Match(MDLParserACCESS) if p.HasError() { // Recognition error - abort rule @@ -63493,7 +69205,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4210) + p.SetState(4634) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -63501,7 +69213,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4211) + p.SetState(4635) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -63509,14 +69221,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4212) + p.SetState(4636) p.QualifiedName() } case 34: p.EnterOuterAlt(localctx, 34) { - p.SetState(4213) + p.SetState(4637) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63524,7 +69236,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4214) + p.SetState(4638) p.Match(MDLParserACCESS) if p.HasError() { // Recognition error - abort rule @@ -63532,7 +69244,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4215) + p.SetState(4639) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -63540,7 +69252,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4216) + p.SetState(4640) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -63548,14 +69260,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4217) + p.SetState(4641) p.QualifiedName() } case 35: p.EnterOuterAlt(localctx, 35) { - p.SetState(4218) + p.SetState(4642) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63563,7 +69275,46 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4219) + p.SetState(4643) + p.Match(MDLParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4644) + p.Match(MDLParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4645) + p.Match(MDLParserWORKFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4646) + p.QualifiedName() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(4647) + p.Match(MDLParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4648) p.Match(MDLParserSECURITY) if p.HasError() { // Recognition error - abort rule @@ -63571,14 +69322,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4220) + p.SetState(4649) p.Match(MDLParserMATRIX) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4226) + p.SetState(4655) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63587,29 +69338,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4221) + p.SetState(4650) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4224) + p.SetState(4653) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 454, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 517, p.GetParserRuleContext()) { case 1: { - p.SetState(4222) + p.SetState(4651) p.QualifiedName() } case 2: { - p.SetState(4223) + p.SetState(4652) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -63623,10 +69374,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 36: - p.EnterOuterAlt(localctx, 36) + case 37: + p.EnterOuterAlt(localctx, 37) { - p.SetState(4228) + p.SetState(4657) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63634,7 +69385,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4229) + p.SetState(4658) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -63642,14 +69393,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4230) + p.SetState(4659) p.Match(MDLParserCLIENTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4236) + p.SetState(4665) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63658,29 +69409,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4231) + p.SetState(4660) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4234) + p.SetState(4663) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 519, p.GetParserRuleContext()) { case 1: { - p.SetState(4232) + p.SetState(4661) p.QualifiedName() } case 2: { - p.SetState(4233) + p.SetState(4662) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -63694,10 +69445,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 37: - p.EnterOuterAlt(localctx, 37) + case 38: + p.EnterOuterAlt(localctx, 38) { - p.SetState(4238) + p.SetState(4667) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63705,7 +69456,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4239) + p.SetState(4668) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -63713,14 +69464,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4240) + p.SetState(4669) p.Match(MDLParserSERVICES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4246) + p.SetState(4675) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63729,29 +69480,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4241) + p.SetState(4670) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4244) + p.SetState(4673) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 458, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 521, p.GetParserRuleContext()) { case 1: { - p.SetState(4242) + p.SetState(4671) p.QualifiedName() } case 2: { - p.SetState(4243) + p.SetState(4672) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -63765,10 +69516,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 38: - p.EnterOuterAlt(localctx, 38) + case 39: + p.EnterOuterAlt(localctx, 39) { - p.SetState(4248) + p.SetState(4677) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63776,7 +69527,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4249) + p.SetState(4678) p.Match(MDLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule @@ -63784,14 +69535,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4250) + p.SetState(4679) p.Match(MDLParserENTITIES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4256) + p.SetState(4685) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63800,29 +69551,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4251) + p.SetState(4680) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4254) + p.SetState(4683) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 460, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 523, p.GetParserRuleContext()) { case 1: { - p.SetState(4252) + p.SetState(4681) p.QualifiedName() } case 2: { - p.SetState(4253) + p.SetState(4682) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -63836,10 +69587,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 39: - p.EnterOuterAlt(localctx, 39) + case 40: + p.EnterOuterAlt(localctx, 40) { - p.SetState(4258) + p.SetState(4687) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63847,7 +69598,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4259) + p.SetState(4688) p.Match(MDLParserNAVIGATION) if p.HasError() { // Recognition error - abort rule @@ -63855,10 +69606,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } - case 40: - p.EnterOuterAlt(localctx, 40) + case 41: + p.EnterOuterAlt(localctx, 41) { - p.SetState(4260) + p.SetState(4689) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63866,7 +69617,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4261) + p.SetState(4690) p.Match(MDLParserNAVIGATION) if p.HasError() { // Recognition error - abort rule @@ -63874,27 +69625,27 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4262) + p.SetState(4691) p.Match(MDLParserMENU_KW) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4265) + p.SetState(4694) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 462, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 525, p.GetParserRuleContext()) == 1 { { - p.SetState(4263) + p.SetState(4692) p.QualifiedName() } } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 462, p.GetParserRuleContext()) == 2 { + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 525, p.GetParserRuleContext()) == 2 { { - p.SetState(4264) + p.SetState(4693) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -63906,10 +69657,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { goto errorExit } - case 41: - p.EnterOuterAlt(localctx, 41) + case 42: + p.EnterOuterAlt(localctx, 42) { - p.SetState(4267) + p.SetState(4696) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63917,7 +69668,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4268) + p.SetState(4697) p.Match(MDLParserNAVIGATION) if p.HasError() { // Recognition error - abort rule @@ -63925,7 +69676,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4269) + p.SetState(4698) p.Match(MDLParserHOMES) if p.HasError() { // Recognition error - abort rule @@ -63933,10 +69684,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } - case 42: - p.EnterOuterAlt(localctx, 42) + case 43: + p.EnterOuterAlt(localctx, 43) { - p.SetState(4270) + p.SetState(4699) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63944,7 +69695,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4271) + p.SetState(4700) p.Match(MDLParserDESIGN) if p.HasError() { // Recognition error - abort rule @@ -63952,14 +69703,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4272) + p.SetState(4701) p.Match(MDLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4275) + p.SetState(4704) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -63968,7 +69719,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserFOR { { - p.SetState(4273) + p.SetState(4702) p.Match(MDLParserFOR) if p.HasError() { // Recognition error - abort rule @@ -63976,16 +69727,16 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4274) + p.SetState(4703) p.WidgetTypeKeyword() } } - case 43: - p.EnterOuterAlt(localctx, 43) + case 44: + p.EnterOuterAlt(localctx, 44) { - p.SetState(4277) + p.SetState(4706) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -63993,14 +69744,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4278) + p.SetState(4707) p.Match(MDLParserSTRUCTURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4281) + p.SetState(4710) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64009,7 +69760,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserDEPTH { { - p.SetState(4279) + p.SetState(4708) p.Match(MDLParserDEPTH) if p.HasError() { // Recognition error - abort rule @@ -64017,7 +69768,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4280) + p.SetState(4709) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -64026,7 +69777,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } - p.SetState(4288) + p.SetState(4717) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64035,29 +69786,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4283) + p.SetState(4712) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4286) + p.SetState(4715) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 465, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 528, p.GetParserRuleContext()) { case 1: { - p.SetState(4284) + p.SetState(4713) p.QualifiedName() } case 2: { - p.SetState(4285) + p.SetState(4714) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -64070,7 +69821,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } - p.SetState(4291) + p.SetState(4720) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64079,7 +69830,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserALL { { - p.SetState(4290) + p.SetState(4719) p.Match(MDLParserALL) if p.HasError() { // Recognition error - abort rule @@ -64089,10 +69840,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 44: - p.EnterOuterAlt(localctx, 44) + case 45: + p.EnterOuterAlt(localctx, 45) { - p.SetState(4293) + p.SetState(4722) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -64100,7 +69851,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4294) + p.SetState(4723) p.Match(MDLParserBUSINESS) if p.HasError() { // Recognition error - abort rule @@ -64108,7 +69859,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4295) + p.SetState(4724) p.Match(MDLParserEVENT) if p.HasError() { // Recognition error - abort rule @@ -64116,14 +69867,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4296) + p.SetState(4725) p.Match(MDLParserSERVICES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4302) + p.SetState(4731) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64132,29 +69883,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4297) + p.SetState(4726) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4300) + p.SetState(4729) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 468, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 531, p.GetParserRuleContext()) { case 1: { - p.SetState(4298) + p.SetState(4727) p.QualifiedName() } case 2: { - p.SetState(4299) + p.SetState(4728) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -64168,10 +69919,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 45: - p.EnterOuterAlt(localctx, 45) + case 46: + p.EnterOuterAlt(localctx, 46) { - p.SetState(4304) + p.SetState(4733) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -64179,7 +69930,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4305) + p.SetState(4734) p.Match(MDLParserBUSINESS) if p.HasError() { // Recognition error - abort rule @@ -64187,7 +69938,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4306) + p.SetState(4735) p.Match(MDLParserEVENT) if p.HasError() { // Recognition error - abort rule @@ -64195,14 +69946,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4307) + p.SetState(4736) p.Match(MDLParserCLIENTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4313) + p.SetState(4742) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64211,29 +69962,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4308) + p.SetState(4737) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4311) + p.SetState(4740) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 470, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 533, p.GetParserRuleContext()) { case 1: { - p.SetState(4309) + p.SetState(4738) p.QualifiedName() } case 2: { - p.SetState(4310) + p.SetState(4739) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -64247,10 +69998,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 46: - p.EnterOuterAlt(localctx, 46) + case 47: + p.EnterOuterAlt(localctx, 47) { - p.SetState(4315) + p.SetState(4744) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -64258,7 +70009,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4316) + p.SetState(4745) p.Match(MDLParserBUSINESS) if p.HasError() { // Recognition error - abort rule @@ -64266,14 +70017,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4317) + p.SetState(4746) p.Match(MDLParserEVENTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4323) + p.SetState(4752) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64282,29 +70033,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4318) + p.SetState(4747) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4321) + p.SetState(4750) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 472, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 535, p.GetParserRuleContext()) { case 1: { - p.SetState(4319) + p.SetState(4748) p.QualifiedName() } case 2: { - p.SetState(4320) + p.SetState(4749) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -64318,10 +70069,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } - case 47: - p.EnterOuterAlt(localctx, 47) + case 48: + p.EnterOuterAlt(localctx, 48) { - p.SetState(4325) + p.SetState(4754) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -64329,7 +70080,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4326) + p.SetState(4755) p.Match(MDLParserSETTINGS) if p.HasError() { // Recognition error - abort rule @@ -64337,10 +70088,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } - case 48: - p.EnterOuterAlt(localctx, 48) + case 49: + p.EnterOuterAlt(localctx, 49) { - p.SetState(4327) + p.SetState(4756) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -64348,7 +70099,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4328) + p.SetState(4757) p.Match(MDLParserFRAGMENTS) if p.HasError() { // Recognition error - abort rule @@ -64356,10 +70107,10 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } - case 49: - p.EnterOuterAlt(localctx, 49) + case 50: + p.EnterOuterAlt(localctx, 50) { - p.SetState(4329) + p.SetState(4758) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -64367,7 +70118,7 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4330) + p.SetState(4759) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -64375,14 +70126,14 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { } } { - p.SetState(4331) + p.SetState(4760) p.Match(MDLParserCONNECTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4337) + p.SetState(4766) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64391,29 +70142,29 @@ func (p *MDLParser) ShowStatement() (localctx IShowStatementContext) { if _la == MDLParserIN { { - p.SetState(4332) + p.SetState(4761) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4335) + p.SetState(4764) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 474, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 537, p.GetParserRuleContext()) { case 1: { - p.SetState(4333) + p.SetState(4762) p.QualifiedName() } case 2: { - p.SetState(4334) + p.SetState(4763) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -64596,10 +70347,10 @@ func (s *ShowWidgetsFilterContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ShowWidgetsFilter() (localctx IShowWidgetsFilterContext) { localctx = NewShowWidgetsFilterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 504, MDLParserRULE_showWidgetsFilter) + p.EnterRule(localctx, 542, MDLParserRULE_showWidgetsFilter) var _la int - p.SetState(4362) + p.SetState(4791) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64609,7 +70360,7 @@ func (p *MDLParser) ShowWidgetsFilter() (localctx IShowWidgetsFilterContext) { case MDLParserWHERE: p.EnterOuterAlt(localctx, 1) { - p.SetState(4341) + p.SetState(4770) p.Match(MDLParserWHERE) if p.HasError() { // Recognition error - abort rule @@ -64617,10 +70368,10 @@ func (p *MDLParser) ShowWidgetsFilter() (localctx IShowWidgetsFilterContext) { } } { - p.SetState(4342) + p.SetState(4771) p.WidgetCondition() } - p.SetState(4347) + p.SetState(4776) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64629,7 +70380,7 @@ func (p *MDLParser) ShowWidgetsFilter() (localctx IShowWidgetsFilterContext) { for _la == MDLParserAND { { - p.SetState(4343) + p.SetState(4772) p.Match(MDLParserAND) if p.HasError() { // Recognition error - abort rule @@ -64637,18 +70388,18 @@ func (p *MDLParser) ShowWidgetsFilter() (localctx IShowWidgetsFilterContext) { } } { - p.SetState(4344) + p.SetState(4773) p.WidgetCondition() } - p.SetState(4349) + p.SetState(4778) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(4355) + p.SetState(4784) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -64657,29 +70408,29 @@ func (p *MDLParser) ShowWidgetsFilter() (localctx IShowWidgetsFilterContext) { if _la == MDLParserIN { { - p.SetState(4350) + p.SetState(4779) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4353) + p.SetState(4782) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 478, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 541, p.GetParserRuleContext()) { case 1: { - p.SetState(4351) + p.SetState(4780) p.QualifiedName() } case 2: { - p.SetState(4352) + p.SetState(4781) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -64696,29 +70447,29 @@ func (p *MDLParser) ShowWidgetsFilter() (localctx IShowWidgetsFilterContext) { case MDLParserIN: p.EnterOuterAlt(localctx, 2) { - p.SetState(4357) + p.SetState(4786) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4360) + p.SetState(4789) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 480, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext()) { case 1: { - p.SetState(4358) + p.SetState(4787) p.QualifiedName() } case 2: { - p.SetState(4359) + p.SetState(4788) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -64950,12 +70701,12 @@ func (s *WidgetTypeKeywordContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WidgetTypeKeyword() (localctx IWidgetTypeKeywordContext) { localctx = NewWidgetTypeKeywordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 506, MDLParserRULE_widgetTypeKeyword) + p.EnterRule(localctx, 544, MDLParserRULE_widgetTypeKeyword) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4364) + p.SetState(4793) _la = p.GetTokenStream().LA(1) if !(((int64((_la-146)) & ^0x3f) == 0 && ((int64(1)<<(_la-146))&211106767466623) != 0) || ((int64((_la-222)) & ^0x3f) == 0 && ((int64(1)<<(_la-222))&31) != 0) || _la == MDLParserIDENTIFIER) { @@ -65071,10 +70822,10 @@ func (s *WidgetConditionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WidgetCondition() (localctx IWidgetConditionContext) { localctx = NewWidgetConditionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 508, MDLParserRULE_widgetCondition) + p.EnterRule(localctx, 546, MDLParserRULE_widgetCondition) var _la int - p.SetState(4372) + p.SetState(4801) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -65084,7 +70835,7 @@ func (p *MDLParser) WidgetCondition() (localctx IWidgetConditionContext) { case MDLParserWIDGETTYPE: p.EnterOuterAlt(localctx, 1) { - p.SetState(4366) + p.SetState(4795) p.Match(MDLParserWIDGETTYPE) if p.HasError() { // Recognition error - abort rule @@ -65092,7 +70843,7 @@ func (p *MDLParser) WidgetCondition() (localctx IWidgetConditionContext) { } } { - p.SetState(4367) + p.SetState(4796) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserLIKE || _la == MDLParserEQUALS) { @@ -65103,7 +70854,7 @@ func (p *MDLParser) WidgetCondition() (localctx IWidgetConditionContext) { } } { - p.SetState(4368) + p.SetState(4797) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -65114,7 +70865,7 @@ func (p *MDLParser) WidgetCondition() (localctx IWidgetConditionContext) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(4369) + p.SetState(4798) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -65122,7 +70873,7 @@ func (p *MDLParser) WidgetCondition() (localctx IWidgetConditionContext) { } } { - p.SetState(4370) + p.SetState(4799) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserLIKE || _la == MDLParserEQUALS) { @@ -65133,7 +70884,7 @@ func (p *MDLParser) WidgetCondition() (localctx IWidgetConditionContext) { } } { - p.SetState(4371) + p.SetState(4800) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -65253,10 +71004,10 @@ func (s *WidgetPropertyAssignmentContext) ExitRule(listener antlr.ParseTreeListe func (p *MDLParser) WidgetPropertyAssignment() (localctx IWidgetPropertyAssignmentContext) { localctx = NewWidgetPropertyAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 510, MDLParserRULE_widgetPropertyAssignment) + p.EnterRule(localctx, 548, MDLParserRULE_widgetPropertyAssignment) p.EnterOuterAlt(localctx, 1) { - p.SetState(4374) + p.SetState(4803) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -65264,7 +71015,7 @@ func (p *MDLParser) WidgetPropertyAssignment() (localctx IWidgetPropertyAssignme } } { - p.SetState(4375) + p.SetState(4804) p.Match(MDLParserEQUALS) if p.HasError() { // Recognition error - abort rule @@ -65272,7 +71023,7 @@ func (p *MDLParser) WidgetPropertyAssignment() (localctx IWidgetPropertyAssignme } } { - p.SetState(4376) + p.SetState(4805) p.WidgetPropertyValue() } @@ -65388,8 +71139,8 @@ func (s *WidgetPropertyValueContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) WidgetPropertyValue() (localctx IWidgetPropertyValueContext) { localctx = NewWidgetPropertyValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 512, MDLParserRULE_widgetPropertyValue) - p.SetState(4382) + p.EnterRule(localctx, 550, MDLParserRULE_widgetPropertyValue) + p.SetState(4811) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -65399,7 +71150,7 @@ func (p *MDLParser) WidgetPropertyValue() (localctx IWidgetPropertyValueContext) case MDLParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 1) { - p.SetState(4378) + p.SetState(4807) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -65410,7 +71161,7 @@ func (p *MDLParser) WidgetPropertyValue() (localctx IWidgetPropertyValueContext) case MDLParserNUMBER_LITERAL: p.EnterOuterAlt(localctx, 2) { - p.SetState(4379) + p.SetState(4808) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -65421,14 +71172,14 @@ func (p *MDLParser) WidgetPropertyValue() (localctx IWidgetPropertyValueContext) case MDLParserTRUE, MDLParserFALSE: p.EnterOuterAlt(localctx, 3) { - p.SetState(4380) + p.SetState(4809) p.BooleanLiteral() } case MDLParserNULL: p.EnterOuterAlt(localctx, 4) { - p.SetState(4381) + p.SetState(4810) p.Match(MDLParserNULL) if p.HasError() { // Recognition error - abort rule @@ -65762,20 +71513,20 @@ func (s *DescribeStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { localctx = NewDescribeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 514, MDLParserRULE_describeStatement) + p.EnterRule(localctx, 552, MDLParserRULE_describeStatement) var _la int - p.SetState(4498) + p.SetState(4927) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 487, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 550, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4384) + p.SetState(4813) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65783,7 +71534,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4385) + p.SetState(4814) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -65791,14 +71542,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4386) + p.SetState(4815) p.QualifiedName() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4387) + p.SetState(4816) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65806,7 +71557,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4388) + p.SetState(4817) p.Match(MDLParserASSOCIATION) if p.HasError() { // Recognition error - abort rule @@ -65814,14 +71565,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4389) + p.SetState(4818) p.QualifiedName() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4390) + p.SetState(4819) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65829,7 +71580,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4391) + p.SetState(4820) p.Match(MDLParserMICROFLOW) if p.HasError() { // Recognition error - abort rule @@ -65837,14 +71588,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4392) + p.SetState(4821) p.QualifiedName() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(4393) + p.SetState(4822) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65852,7 +71603,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4394) + p.SetState(4823) p.Match(MDLParserNANOFLOW) if p.HasError() { // Recognition error - abort rule @@ -65860,14 +71611,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4395) + p.SetState(4824) p.QualifiedName() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(4396) + p.SetState(4825) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65875,7 +71626,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4397) + p.SetState(4826) p.Match(MDLParserWORKFLOW) if p.HasError() { // Recognition error - abort rule @@ -65883,14 +71634,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4398) + p.SetState(4827) p.QualifiedName() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(4399) + p.SetState(4828) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65898,7 +71649,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4400) + p.SetState(4829) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -65906,14 +71657,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4401) + p.SetState(4830) p.QualifiedName() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(4402) + p.SetState(4831) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65921,7 +71672,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4403) + p.SetState(4832) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -65929,14 +71680,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4404) + p.SetState(4833) p.QualifiedName() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(4405) + p.SetState(4834) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65944,7 +71695,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4406) + p.SetState(4835) p.Match(MDLParserLAYOUT) if p.HasError() { // Recognition error - abort rule @@ -65952,14 +71703,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4407) + p.SetState(4836) p.QualifiedName() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(4408) + p.SetState(4837) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65967,7 +71718,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4409) + p.SetState(4838) p.Match(MDLParserENUMERATION) if p.HasError() { // Recognition error - abort rule @@ -65975,14 +71726,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4410) + p.SetState(4839) p.QualifiedName() } case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(4411) + p.SetState(4840) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -65990,7 +71741,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4412) + p.SetState(4841) p.Match(MDLParserCONSTANT) if p.HasError() { // Recognition error - abort rule @@ -65998,14 +71749,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4413) + p.SetState(4842) p.QualifiedName() } case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(4414) + p.SetState(4843) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66013,7 +71764,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4415) + p.SetState(4844) p.Match(MDLParserJAVA) if p.HasError() { // Recognition error - abort rule @@ -66021,7 +71772,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4416) + p.SetState(4845) p.Match(MDLParserACTION) if p.HasError() { // Recognition error - abort rule @@ -66029,14 +71780,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4417) + p.SetState(4846) p.QualifiedName() } case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(4418) + p.SetState(4847) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66044,7 +71795,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4419) + p.SetState(4848) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -66052,14 +71803,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4420) + p.SetState(4849) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4423) + p.SetState(4852) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -66068,7 +71819,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { if _la == MDLParserWITH { { - p.SetState(4421) + p.SetState(4850) p.Match(MDLParserWITH) if p.HasError() { // Recognition error - abort rule @@ -66076,7 +71827,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4422) + p.SetState(4851) p.Match(MDLParserALL) if p.HasError() { // Recognition error - abort rule @@ -66089,7 +71840,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(4425) + p.SetState(4854) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66097,7 +71848,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4426) + p.SetState(4855) p.Match(MDLParserMODULE) if p.HasError() { // Recognition error - abort rule @@ -66105,7 +71856,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4427) + p.SetState(4856) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -66113,14 +71864,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4428) + p.SetState(4857) p.QualifiedName() } case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(4429) + p.SetState(4858) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66128,7 +71879,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4430) + p.SetState(4859) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -66136,7 +71887,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4431) + p.SetState(4860) p.Match(MDLParserROLE) if p.HasError() { // Recognition error - abort rule @@ -66144,7 +71895,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4432) + p.SetState(4861) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -66155,7 +71906,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(4433) + p.SetState(4862) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66163,7 +71914,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4434) + p.SetState(4863) p.Match(MDLParserDEMO) if p.HasError() { // Recognition error - abort rule @@ -66171,7 +71922,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4435) + p.SetState(4864) p.Match(MDLParserUSER) if p.HasError() { // Recognition error - abort rule @@ -66179,7 +71930,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4436) + p.SetState(4865) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -66190,7 +71941,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { case 16: p.EnterOuterAlt(localctx, 16) { - p.SetState(4437) + p.SetState(4866) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66198,7 +71949,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4438) + p.SetState(4867) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -66206,7 +71957,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4439) + p.SetState(4868) p.Match(MDLParserCLIENT) if p.HasError() { // Recognition error - abort rule @@ -66214,14 +71965,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4440) + p.SetState(4869) p.QualifiedName() } case 17: p.EnterOuterAlt(localctx, 17) { - p.SetState(4441) + p.SetState(4870) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66229,7 +71980,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4442) + p.SetState(4871) p.Match(MDLParserODATA) if p.HasError() { // Recognition error - abort rule @@ -66237,7 +71988,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4443) + p.SetState(4872) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -66245,14 +71996,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4444) + p.SetState(4873) p.QualifiedName() } case 18: p.EnterOuterAlt(localctx, 18) { - p.SetState(4445) + p.SetState(4874) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66260,7 +72011,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4446) + p.SetState(4875) p.Match(MDLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule @@ -66268,7 +72019,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4447) + p.SetState(4876) p.Match(MDLParserENTITY) if p.HasError() { // Recognition error - abort rule @@ -66276,14 +72027,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4448) + p.SetState(4877) p.QualifiedName() } case 19: p.EnterOuterAlt(localctx, 19) { - p.SetState(4449) + p.SetState(4878) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66291,27 +72042,27 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4450) + p.SetState(4879) p.Match(MDLParserNAVIGATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4453) + p.SetState(4882) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 548, p.GetParserRuleContext()) == 1 { { - p.SetState(4451) + p.SetState(4880) p.QualifiedName() } } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) == 2 { + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 548, p.GetParserRuleContext()) == 2 { { - p.SetState(4452) + p.SetState(4881) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -66326,7 +72077,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { case 20: p.EnterOuterAlt(localctx, 20) { - p.SetState(4455) + p.SetState(4884) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66334,7 +72085,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4456) + p.SetState(4885) p.Match(MDLParserSTYLING) if p.HasError() { // Recognition error - abort rule @@ -66342,7 +72093,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4457) + p.SetState(4886) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -66350,7 +72101,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4458) + p.SetState(4887) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserPAGE || _la == MDLParserSNIPPET) { @@ -66361,10 +72112,10 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4459) + p.SetState(4888) p.QualifiedName() } - p.SetState(4462) + p.SetState(4891) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -66373,7 +72124,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { if _la == MDLParserWIDGET { { - p.SetState(4460) + p.SetState(4889) p.Match(MDLParserWIDGET) if p.HasError() { // Recognition error - abort rule @@ -66381,7 +72132,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4461) + p.SetState(4890) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -66394,7 +72145,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { case 21: p.EnterOuterAlt(localctx, 21) { - p.SetState(4464) + p.SetState(4893) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66402,7 +72153,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4465) + p.SetState(4894) p.Match(MDLParserCATALOG) if p.HasError() { // Recognition error - abort rule @@ -66410,7 +72161,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4466) + p.SetState(4895) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule @@ -66419,14 +72170,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } { - p.SetState(4467) + p.SetState(4896) p.CatalogTableName() } case 22: p.EnterOuterAlt(localctx, 22) { - p.SetState(4468) + p.SetState(4897) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66434,7 +72185,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4469) + p.SetState(4898) p.Match(MDLParserBUSINESS) if p.HasError() { // Recognition error - abort rule @@ -66442,7 +72193,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4470) + p.SetState(4899) p.Match(MDLParserEVENT) if p.HasError() { // Recognition error - abort rule @@ -66450,7 +72201,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4471) + p.SetState(4900) p.Match(MDLParserSERVICE) if p.HasError() { // Recognition error - abort rule @@ -66458,14 +72209,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4472) + p.SetState(4901) p.QualifiedName() } case 23: p.EnterOuterAlt(localctx, 23) { - p.SetState(4473) + p.SetState(4902) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66473,7 +72224,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4474) + p.SetState(4903) p.Match(MDLParserDATABASE) if p.HasError() { // Recognition error - abort rule @@ -66481,7 +72232,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4475) + p.SetState(4904) p.Match(MDLParserCONNECTION) if p.HasError() { // Recognition error - abort rule @@ -66489,14 +72240,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4476) + p.SetState(4905) p.QualifiedName() } case 24: p.EnterOuterAlt(localctx, 24) { - p.SetState(4477) + p.SetState(4906) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66504,7 +72255,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4478) + p.SetState(4907) p.Match(MDLParserSETTINGS) if p.HasError() { // Recognition error - abort rule @@ -66515,7 +72266,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { case 25: p.EnterOuterAlt(localctx, 25) { - p.SetState(4479) + p.SetState(4908) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66523,7 +72274,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4480) + p.SetState(4909) p.Match(MDLParserFRAGMENT) if p.HasError() { // Recognition error - abort rule @@ -66531,7 +72282,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4481) + p.SetState(4910) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -66539,7 +72290,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4482) + p.SetState(4911) p.Match(MDLParserPAGE) if p.HasError() { // Recognition error - abort rule @@ -66547,11 +72298,11 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4483) + p.SetState(4912) p.QualifiedName() } { - p.SetState(4484) + p.SetState(4913) p.Match(MDLParserWIDGET) if p.HasError() { // Recognition error - abort rule @@ -66559,14 +72310,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4485) + p.SetState(4914) p.IdentifierOrKeyword() } case 26: p.EnterOuterAlt(localctx, 26) { - p.SetState(4487) + p.SetState(4916) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66574,7 +72325,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4488) + p.SetState(4917) p.Match(MDLParserFRAGMENT) if p.HasError() { // Recognition error - abort rule @@ -66582,7 +72333,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4489) + p.SetState(4918) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -66590,7 +72341,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4490) + p.SetState(4919) p.Match(MDLParserSNIPPET) if p.HasError() { // Recognition error - abort rule @@ -66598,11 +72349,11 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4491) + p.SetState(4920) p.QualifiedName() } { - p.SetState(4492) + p.SetState(4921) p.Match(MDLParserWIDGET) if p.HasError() { // Recognition error - abort rule @@ -66610,14 +72361,14 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4493) + p.SetState(4922) p.IdentifierOrKeyword() } case 27: p.EnterOuterAlt(localctx, 27) { - p.SetState(4495) + p.SetState(4924) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -66625,7 +72376,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4496) + p.SetState(4925) p.Match(MDLParserFRAGMENT) if p.HasError() { // Recognition error - abort rule @@ -66633,7 +72384,7 @@ func (p *MDLParser) DescribeStatement() (localctx IDescribeStatementContext) { } } { - p.SetState(4497) + p.SetState(4926) p.IdentifierOrKeyword() } @@ -66977,24 +72728,24 @@ func (s *CatalogSelectQueryContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { localctx = NewCatalogSelectQueryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 516, MDLParserRULE_catalogSelectQuery) + p.EnterRule(localctx, 554, MDLParserRULE_catalogSelectQuery) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4500) + p.SetState(4929) p.Match(MDLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4502) + p.SetState(4931) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 488, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 551, p.GetParserRuleContext()) == 1 { { - p.SetState(4501) + p.SetState(4930) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserDISTINCT || _la == MDLParserALL) { @@ -67009,11 +72760,11 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { goto errorExit } { - p.SetState(4504) + p.SetState(4933) p.SelectList() } { - p.SetState(4505) + p.SetState(4934) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -67021,7 +72772,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4506) + p.SetState(4935) p.Match(MDLParserCATALOG) if p.HasError() { // Recognition error - abort rule @@ -67029,7 +72780,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4507) + p.SetState(4936) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule @@ -67037,14 +72788,14 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4508) + p.SetState(4937) p.CatalogTableName() } - p.SetState(4513) + p.SetState(4942) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 490, p.GetParserRuleContext()) == 1 { - p.SetState(4510) + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 553, p.GetParserRuleContext()) == 1 { + p.SetState(4939) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67053,7 +72804,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { if _la == MDLParserAS { { - p.SetState(4509) + p.SetState(4938) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -67063,7 +72814,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } { - p.SetState(4512) + p.SetState(4941) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -67074,7 +72825,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } else if p.HasError() { // JIM goto errorExit } - p.SetState(4518) + p.SetState(4947) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67083,18 +72834,18 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { for (int64((_la-85)) & ^0x3f) == 0 && ((int64(1)<<(_la-85))&111) != 0 { { - p.SetState(4515) + p.SetState(4944) p.CatalogJoinClause() } - p.SetState(4520) + p.SetState(4949) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(4523) + p.SetState(4952) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67103,7 +72854,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { if _la == MDLParserWHERE { { - p.SetState(4521) + p.SetState(4950) p.Match(MDLParserWHERE) if p.HasError() { // Recognition error - abort rule @@ -67111,7 +72862,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4522) + p.SetState(4951) var _x = p.Expression() @@ -67119,7 +72870,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } - p.SetState(4531) + p.SetState(4960) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67128,7 +72879,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { if _la == MDLParserGROUP_BY { { - p.SetState(4525) + p.SetState(4954) p.Match(MDLParserGROUP_BY) if p.HasError() { // Recognition error - abort rule @@ -67136,10 +72887,10 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4526) + p.SetState(4955) p.GroupByList() } - p.SetState(4529) + p.SetState(4958) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67148,7 +72899,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { if _la == MDLParserHAVING { { - p.SetState(4527) + p.SetState(4956) p.Match(MDLParserHAVING) if p.HasError() { // Recognition error - abort rule @@ -67156,7 +72907,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4528) + p.SetState(4957) var _x = p.Expression() @@ -67166,7 +72917,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } - p.SetState(4535) + p.SetState(4964) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67175,7 +72926,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { if _la == MDLParserORDER_BY { { - p.SetState(4533) + p.SetState(4962) p.Match(MDLParserORDER_BY) if p.HasError() { // Recognition error - abort rule @@ -67183,12 +72934,12 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4534) + p.SetState(4963) p.OrderByList() } } - p.SetState(4539) + p.SetState(4968) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67197,7 +72948,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { if _la == MDLParserLIMIT { { - p.SetState(4537) + p.SetState(4966) p.Match(MDLParserLIMIT) if p.HasError() { // Recognition error - abort rule @@ -67205,7 +72956,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4538) + p.SetState(4967) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -67214,7 +72965,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } - p.SetState(4543) + p.SetState(4972) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67223,7 +72974,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { if _la == MDLParserOFFSET { { - p.SetState(4541) + p.SetState(4970) p.Match(MDLParserOFFSET) if p.HasError() { // Recognition error - abort rule @@ -67231,7 +72982,7 @@ func (p *MDLParser) CatalogSelectQuery() (localctx ICatalogSelectQueryContext) { } } { - p.SetState(4542) + p.SetState(4971) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -67402,11 +73153,11 @@ func (s *CatalogJoinClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { localctx = NewCatalogJoinClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 518, MDLParserRULE_catalogJoinClause) + p.EnterRule(localctx, 556, MDLParserRULE_catalogJoinClause) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(4546) + p.SetState(4975) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67415,13 +73166,13 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { if (int64((_la-86)) & ^0x3f) == 0 && ((int64(1)<<(_la-86))&55) != 0 { { - p.SetState(4545) + p.SetState(4974) p.JoinType() } } { - p.SetState(4548) + p.SetState(4977) p.Match(MDLParserJOIN) if p.HasError() { // Recognition error - abort rule @@ -67429,7 +73180,7 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { } } { - p.SetState(4549) + p.SetState(4978) p.Match(MDLParserCATALOG) if p.HasError() { // Recognition error - abort rule @@ -67437,7 +73188,7 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { } } { - p.SetState(4550) + p.SetState(4979) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule @@ -67445,14 +73196,14 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { } } { - p.SetState(4551) + p.SetState(4980) p.CatalogTableName() } - p.SetState(4556) + p.SetState(4985) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 500, p.GetParserRuleContext()) == 1 { - p.SetState(4553) + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext()) == 1 { + p.SetState(4982) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67461,7 +73212,7 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { if _la == MDLParserAS { { - p.SetState(4552) + p.SetState(4981) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -67471,7 +73222,7 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { } { - p.SetState(4555) + p.SetState(4984) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -67482,7 +73233,7 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { } else if p.HasError() { // JIM goto errorExit } - p.SetState(4560) + p.SetState(4989) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67491,7 +73242,7 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { if _la == MDLParserON { { - p.SetState(4558) + p.SetState(4987) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -67499,7 +73250,7 @@ func (p *MDLParser) CatalogJoinClause() (localctx ICatalogJoinClauseContext) { } } { - p.SetState(4559) + p.SetState(4988) p.Expression() } @@ -67655,15 +73406,15 @@ func (s *CatalogTableNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CatalogTableName() (localctx ICatalogTableNameContext) { localctx = NewCatalogTableNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 520, MDLParserRULE_catalogTableName) + p.EnterRule(localctx, 558, MDLParserRULE_catalogTableName) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4562) + p.SetState(4991) _la = p.GetTokenStream().LA(1) - if !(((int64((_la-141)) & ^0x3f) == 0 && ((int64(1)<<(_la-141))&580542139465735) != 0) || _la == MDLParserATTRIBUTES || ((int64((_la-308)) & ^0x3f) == 0 && ((int64(1)<<(_la-308))&-2882303761517117439) != 0) || _la == MDLParserWORKFLOWS || _la == MDLParserENUMERATIONS || _la == MDLParserIDENTIFIER) { + if !(((int64((_la-141)) & ^0x3f) == 0 && ((int64(1)<<(_la-141))&580542139465735) != 0) || _la == MDLParserATTRIBUTES || ((int64((_la-309)) & ^0x3f) == 0 && ((int64(1)<<(_la-309))&-2882303761517117439) != 0) || _la == MDLParserWORKFLOWS || _la == MDLParserENUMERATIONS || _la == MDLParserIDENTIFIER) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -67814,15 +73565,15 @@ func (s *OqlQueryContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OqlQuery() (localctx IOqlQueryContext) { localctx = NewOqlQueryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 522, MDLParserRULE_oqlQuery) + p.EnterRule(localctx, 560, MDLParserRULE_oqlQuery) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4564) + p.SetState(4993) p.OqlQueryTerm() } - p.SetState(4572) + p.SetState(5001) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67831,14 +73582,14 @@ func (p *MDLParser) OqlQuery() (localctx IOqlQueryContext) { for _la == MDLParserUNION { { - p.SetState(4565) + p.SetState(4994) p.Match(MDLParserUNION) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4567) + p.SetState(4996) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -67847,7 +73598,7 @@ func (p *MDLParser) OqlQuery() (localctx IOqlQueryContext) { if _la == MDLParserALL { { - p.SetState(4566) + p.SetState(4995) p.Match(MDLParserALL) if p.HasError() { // Recognition error - abort rule @@ -67857,11 +73608,11 @@ func (p *MDLParser) OqlQuery() (localctx IOqlQueryContext) { } { - p.SetState(4569) + p.SetState(4998) p.OqlQueryTerm() } - p.SetState(4574) + p.SetState(5003) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68068,10 +73819,10 @@ func (s *OqlQueryTermContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { localctx = NewOqlQueryTermContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 524, MDLParserRULE_oqlQueryTerm) + p.EnterRule(localctx, 562, MDLParserRULE_oqlQueryTerm) var _la int - p.SetState(4611) + p.SetState(5040) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68081,22 +73832,22 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { case MDLParserSELECT: p.EnterOuterAlt(localctx, 1) { - p.SetState(4575) + p.SetState(5004) p.SelectClause() } - p.SetState(4577) + p.SetState(5006) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 504, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 1 { { - p.SetState(4576) + p.SetState(5005) p.FromClause() } } else if p.HasError() { // JIM goto errorExit } - p.SetState(4580) + p.SetState(5009) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68105,12 +73856,12 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserWHERE { { - p.SetState(4579) + p.SetState(5008) p.WhereClause() } } - p.SetState(4583) + p.SetState(5012) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68119,12 +73870,12 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserGROUP_BY { { - p.SetState(4582) + p.SetState(5011) p.GroupByClause() } } - p.SetState(4586) + p.SetState(5015) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68133,12 +73884,12 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserHAVING { { - p.SetState(4585) + p.SetState(5014) p.HavingClause() } } - p.SetState(4589) + p.SetState(5018) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68147,12 +73898,12 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserORDER_BY { { - p.SetState(4588) + p.SetState(5017) p.OrderByClause() } } - p.SetState(4592) + p.SetState(5021) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68161,7 +73912,7 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserOFFSET || _la == MDLParserLIMIT { { - p.SetState(4591) + p.SetState(5020) p.LimitOffsetClause() } @@ -68170,10 +73921,10 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { case MDLParserFROM: p.EnterOuterAlt(localctx, 2) { - p.SetState(4594) + p.SetState(5023) p.FromClause() } - p.SetState(4596) + p.SetState(5025) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68182,12 +73933,12 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserWHERE { { - p.SetState(4595) + p.SetState(5024) p.WhereClause() } } - p.SetState(4599) + p.SetState(5028) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68196,12 +73947,12 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserGROUP_BY { { - p.SetState(4598) + p.SetState(5027) p.GroupByClause() } } - p.SetState(4602) + p.SetState(5031) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68210,16 +73961,16 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserHAVING { { - p.SetState(4601) + p.SetState(5030) p.HavingClause() } } { - p.SetState(4604) + p.SetState(5033) p.SelectClause() } - p.SetState(4606) + p.SetState(5035) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68228,12 +73979,12 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserORDER_BY { { - p.SetState(4605) + p.SetState(5034) p.OrderByClause() } } - p.SetState(4609) + p.SetState(5038) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68242,7 +73993,7 @@ func (p *MDLParser) OqlQueryTerm() (localctx IOqlQueryTermContext) { if _la == MDLParserOFFSET || _la == MDLParserLIMIT { { - p.SetState(4608) + p.SetState(5037) p.LimitOffsetClause() } @@ -68365,24 +74116,24 @@ func (s *SelectClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SelectClause() (localctx ISelectClauseContext) { localctx = NewSelectClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 526, MDLParserRULE_selectClause) + p.EnterRule(localctx, 564, MDLParserRULE_selectClause) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4613) + p.SetState(5042) p.Match(MDLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4615) + p.SetState(5044) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 516, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 579, p.GetParserRuleContext()) == 1 { { - p.SetState(4614) + p.SetState(5043) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserDISTINCT || _la == MDLParserALL) { @@ -68397,7 +74148,7 @@ func (p *MDLParser) SelectClause() (localctx ISelectClauseContext) { goto errorExit } { - p.SetState(4617) + p.SetState(5046) p.SelectList() } @@ -68539,10 +74290,10 @@ func (s *SelectListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SelectList() (localctx ISelectListContext) { localctx = NewSelectListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 528, MDLParserRULE_selectList) + p.EnterRule(localctx, 566, MDLParserRULE_selectList) var _la int - p.SetState(4628) + p.SetState(5057) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68552,7 +74303,7 @@ func (p *MDLParser) SelectList() (localctx ISelectListContext) { case MDLParserSTAR: p.EnterOuterAlt(localctx, 1) { - p.SetState(4619) + p.SetState(5048) p.Match(MDLParserSTAR) if p.HasError() { // Recognition error - abort rule @@ -68560,13 +74311,13 @@ func (p *MDLParser) SelectList() (localctx ISelectListContext) { } } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(4620) + p.SetState(5049) p.SelectItem() } - p.SetState(4625) + p.SetState(5054) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68575,7 +74326,7 @@ func (p *MDLParser) SelectList() (localctx ISelectListContext) { for _la == MDLParserCOMMA { { - p.SetState(4621) + p.SetState(5050) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -68583,11 +74334,11 @@ func (p *MDLParser) SelectList() (localctx ISelectListContext) { } } { - p.SetState(4622) + p.SetState(5051) p.SelectItem() } - p.SetState(4627) + p.SetState(5056) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68736,23 +74487,23 @@ func (s *SelectItemContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SelectItem() (localctx ISelectItemContext) { localctx = NewSelectItemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 530, MDLParserRULE_selectItem) + p.EnterRule(localctx, 568, MDLParserRULE_selectItem) var _la int - p.SetState(4640) + p.SetState(5069) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 521, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 584, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4630) + p.SetState(5059) p.Expression() } - p.SetState(4633) + p.SetState(5062) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68761,7 +74512,7 @@ func (p *MDLParser) SelectItem() (localctx ISelectItemContext) { if _la == MDLParserAS { { - p.SetState(4631) + p.SetState(5060) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -68769,7 +74520,7 @@ func (p *MDLParser) SelectItem() (localctx ISelectItemContext) { } } { - p.SetState(4632) + p.SetState(5061) p.SelectAlias() } @@ -68778,10 +74529,10 @@ func (p *MDLParser) SelectItem() (localctx ISelectItemContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4635) + p.SetState(5064) p.AggregateFunction() } - p.SetState(4638) + p.SetState(5067) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68790,7 +74541,7 @@ func (p *MDLParser) SelectItem() (localctx ISelectItemContext) { if _la == MDLParserAS { { - p.SetState(4636) + p.SetState(5065) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -68798,7 +74549,7 @@ func (p *MDLParser) SelectItem() (localctx ISelectItemContext) { } } { - p.SetState(4637) + p.SetState(5066) p.SelectAlias() } @@ -68910,8 +74661,8 @@ func (s *SelectAliasContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SelectAlias() (localctx ISelectAliasContext) { localctx = NewSelectAliasContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 532, MDLParserRULE_selectAlias) - p.SetState(4644) + p.EnterRule(localctx, 570, MDLParserRULE_selectAlias) + p.SetState(5073) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -68921,7 +74672,7 @@ func (p *MDLParser) SelectAlias() (localctx ISelectAliasContext) { case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(4642) + p.SetState(5071) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -68932,7 +74683,7 @@ func (p *MDLParser) SelectAlias() (localctx ISelectAliasContext) { case MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserDEBUG, MDLParserACTION, MDLParserSORT, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserTITLE, MDLParserLABEL, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserEDITABLE, MDLParserVISIBLE, MDLParserSUCCESS, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserERROR, MDLParserRANGE, MDLParserSTATUS, MDLParserVERSION, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserNAVIGATION, MDLParserHOME, MDLParserCHECK, MDLParserTEXT, MDLParserMESSAGE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserFORMAT, MDLParserROLE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserDESCRIPTION, MDLParserOFF: p.EnterOuterAlt(localctx, 2) { - p.SetState(4643) + p.SetState(5072) p.CommonNameKeyword() } @@ -69086,12 +74837,12 @@ func (s *FromClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) FromClause() (localctx IFromClauseContext) { localctx = NewFromClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 534, MDLParserRULE_fromClause) + p.EnterRule(localctx, 572, MDLParserRULE_fromClause) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4646) + p.SetState(5075) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -69099,10 +74850,10 @@ func (p *MDLParser) FromClause() (localctx IFromClauseContext) { } } { - p.SetState(4647) + p.SetState(5076) p.TableReference() } - p.SetState(4651) + p.SetState(5080) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69111,11 +74862,11 @@ func (p *MDLParser) FromClause() (localctx IFromClauseContext) { for (int64((_la-85)) & ^0x3f) == 0 && ((int64(1)<<(_la-85))&111) != 0 { { - p.SetState(4648) + p.SetState(5077) p.JoinClause() } - p.SetState(4653) + p.SetState(5082) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69257,27 +75008,27 @@ func (s *TableReferenceContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) TableReference() (localctx ITableReferenceContext) { localctx = NewTableReferenceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 536, MDLParserRULE_tableReference) + p.EnterRule(localctx, 574, MDLParserRULE_tableReference) var _la int - p.SetState(4670) + p.SetState(5099) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV, MDLParserIDENTIFIER, MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(4654) + p.SetState(5083) p.QualifiedName() } - p.SetState(4659) + p.SetState(5088) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 525, p.GetParserRuleContext()) == 1 { - p.SetState(4656) + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) == 1 { + p.SetState(5085) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69286,7 +75037,7 @@ func (p *MDLParser) TableReference() (localctx ITableReferenceContext) { if _la == MDLParserAS { { - p.SetState(4655) + p.SetState(5084) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -69296,7 +75047,7 @@ func (p *MDLParser) TableReference() (localctx ITableReferenceContext) { } { - p.SetState(4658) + p.SetState(5087) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -69311,7 +75062,7 @@ func (p *MDLParser) TableReference() (localctx ITableReferenceContext) { case MDLParserLPAREN: p.EnterOuterAlt(localctx, 2) { - p.SetState(4661) + p.SetState(5090) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -69319,22 +75070,22 @@ func (p *MDLParser) TableReference() (localctx ITableReferenceContext) { } } { - p.SetState(4662) + p.SetState(5091) p.OqlQuery() } { - p.SetState(4663) + p.SetState(5092) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4668) + p.SetState(5097) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 527, p.GetParserRuleContext()) == 1 { - p.SetState(4665) + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 590, p.GetParserRuleContext()) == 1 { + p.SetState(5094) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69343,7 +75094,7 @@ func (p *MDLParser) TableReference() (localctx ITableReferenceContext) { if _la == MDLParserAS { { - p.SetState(4664) + p.SetState(5093) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -69353,7 +75104,7 @@ func (p *MDLParser) TableReference() (localctx ITableReferenceContext) { } { - p.SetState(4667) + p.SetState(5096) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -69538,19 +75289,19 @@ func (s *JoinClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { localctx = NewJoinClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 538, MDLParserRULE_joinClause) + p.EnterRule(localctx, 576, MDLParserRULE_joinClause) var _la int - p.SetState(4692) + p.SetState(5121) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 534, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) - p.SetState(4673) + p.SetState(5102) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69559,13 +75310,13 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { if (int64((_la-86)) & ^0x3f) == 0 && ((int64(1)<<(_la-86))&55) != 0 { { - p.SetState(4672) + p.SetState(5101) p.JoinType() } } { - p.SetState(4675) + p.SetState(5104) p.Match(MDLParserJOIN) if p.HasError() { // Recognition error - abort rule @@ -69573,10 +75324,10 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { } } { - p.SetState(4676) + p.SetState(5105) p.TableReference() } - p.SetState(4679) + p.SetState(5108) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69585,7 +75336,7 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { if _la == MDLParserON { { - p.SetState(4677) + p.SetState(5106) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -69593,7 +75344,7 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { } } { - p.SetState(4678) + p.SetState(5107) p.Expression() } @@ -69601,7 +75352,7 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { case 2: p.EnterOuterAlt(localctx, 2) - p.SetState(4682) + p.SetState(5111) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69610,13 +75361,13 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { if (int64((_la-86)) & ^0x3f) == 0 && ((int64(1)<<(_la-86))&55) != 0 { { - p.SetState(4681) + p.SetState(5110) p.JoinType() } } { - p.SetState(4684) + p.SetState(5113) p.Match(MDLParserJOIN) if p.HasError() { // Recognition error - abort rule @@ -69624,14 +75375,14 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { } } { - p.SetState(4685) + p.SetState(5114) p.AssociationPath() } - p.SetState(4690) + p.SetState(5119) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 533, p.GetParserRuleContext()) == 1 { - p.SetState(4687) + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 596, p.GetParserRuleContext()) == 1 { + p.SetState(5116) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69640,7 +75391,7 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { if _la == MDLParserAS { { - p.SetState(4686) + p.SetState(5115) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -69650,7 +75401,7 @@ func (p *MDLParser) JoinClause() (localctx IJoinClauseContext) { } { - p.SetState(4689) + p.SetState(5118) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -69804,18 +75555,18 @@ func (s *AssociationPathContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AssociationPath() (localctx IAssociationPathContext) { localctx = NewAssociationPathContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 540, MDLParserRULE_associationPath) - p.SetState(4704) + p.EnterRule(localctx, 578, MDLParserRULE_associationPath) + p.SetState(5133) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 535, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4694) + p.SetState(5123) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -69823,7 +75574,7 @@ func (p *MDLParser) AssociationPath() (localctx IAssociationPathContext) { } } { - p.SetState(4695) + p.SetState(5124) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule @@ -69831,11 +75582,11 @@ func (p *MDLParser) AssociationPath() (localctx IAssociationPathContext) { } } { - p.SetState(4696) + p.SetState(5125) p.QualifiedName() } { - p.SetState(4697) + p.SetState(5126) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule @@ -69843,18 +75594,18 @@ func (p *MDLParser) AssociationPath() (localctx IAssociationPathContext) { } } { - p.SetState(4698) + p.SetState(5127) p.QualifiedName() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4700) + p.SetState(5129) p.QualifiedName() } { - p.SetState(4701) + p.SetState(5130) p.Match(MDLParserSLASH) if p.HasError() { // Recognition error - abort rule @@ -69862,7 +75613,7 @@ func (p *MDLParser) AssociationPath() (localctx IAssociationPathContext) { } } { - p.SetState(4702) + p.SetState(5131) p.QualifiedName() } @@ -69980,10 +75731,10 @@ func (s *JoinTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { localctx = NewJoinTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 542, MDLParserRULE_joinType) + p.EnterRule(localctx, 580, MDLParserRULE_joinType) var _la int - p.SetState(4720) + p.SetState(5149) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -69993,14 +75744,14 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { case MDLParserLEFT: p.EnterOuterAlt(localctx, 1) { - p.SetState(4706) + p.SetState(5135) p.Match(MDLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4708) + p.SetState(5137) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -70009,7 +75760,7 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { if _la == MDLParserOUTER { { - p.SetState(4707) + p.SetState(5136) p.Match(MDLParserOUTER) if p.HasError() { // Recognition error - abort rule @@ -70022,14 +75773,14 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { case MDLParserRIGHT: p.EnterOuterAlt(localctx, 2) { - p.SetState(4710) + p.SetState(5139) p.Match(MDLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4712) + p.SetState(5141) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -70038,7 +75789,7 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { if _la == MDLParserOUTER { { - p.SetState(4711) + p.SetState(5140) p.Match(MDLParserOUTER) if p.HasError() { // Recognition error - abort rule @@ -70051,7 +75802,7 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { case MDLParserINNER: p.EnterOuterAlt(localctx, 3) { - p.SetState(4714) + p.SetState(5143) p.Match(MDLParserINNER) if p.HasError() { // Recognition error - abort rule @@ -70062,14 +75813,14 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { case MDLParserFULL: p.EnterOuterAlt(localctx, 4) { - p.SetState(4715) + p.SetState(5144) p.Match(MDLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4717) + p.SetState(5146) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -70078,7 +75829,7 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { if _la == MDLParserOUTER { { - p.SetState(4716) + p.SetState(5145) p.Match(MDLParserOUTER) if p.HasError() { // Recognition error - abort rule @@ -70091,7 +75842,7 @@ func (p *MDLParser) JoinType() (localctx IJoinTypeContext) { case MDLParserCROSS: p.EnterOuterAlt(localctx, 5) { - p.SetState(4719) + p.SetState(5148) p.Match(MDLParserCROSS) if p.HasError() { // Recognition error - abort rule @@ -70206,10 +75957,10 @@ func (s *WhereClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) WhereClause() (localctx IWhereClauseContext) { localctx = NewWhereClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 544, MDLParserRULE_whereClause) + p.EnterRule(localctx, 582, MDLParserRULE_whereClause) p.EnterOuterAlt(localctx, 1) { - p.SetState(4722) + p.SetState(5151) p.Match(MDLParserWHERE) if p.HasError() { // Recognition error - abort rule @@ -70217,7 +75968,7 @@ func (p *MDLParser) WhereClause() (localctx IWhereClauseContext) { } } { - p.SetState(4723) + p.SetState(5152) p.Expression() } @@ -70323,10 +76074,10 @@ func (s *GroupByClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) GroupByClause() (localctx IGroupByClauseContext) { localctx = NewGroupByClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 546, MDLParserRULE_groupByClause) + p.EnterRule(localctx, 584, MDLParserRULE_groupByClause) p.EnterOuterAlt(localctx, 1) { - p.SetState(4725) + p.SetState(5154) p.Match(MDLParserGROUP_BY) if p.HasError() { // Recognition error - abort rule @@ -70334,7 +76085,7 @@ func (p *MDLParser) GroupByClause() (localctx IGroupByClauseContext) { } } { - p.SetState(4726) + p.SetState(5155) p.ExpressionList() } @@ -70440,10 +76191,10 @@ func (s *HavingClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) HavingClause() (localctx IHavingClauseContext) { localctx = NewHavingClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 548, MDLParserRULE_havingClause) + p.EnterRule(localctx, 586, MDLParserRULE_havingClause) p.EnterOuterAlt(localctx, 1) { - p.SetState(4728) + p.SetState(5157) p.Match(MDLParserHAVING) if p.HasError() { // Recognition error - abort rule @@ -70451,7 +76202,7 @@ func (p *MDLParser) HavingClause() (localctx IHavingClauseContext) { } } { - p.SetState(4729) + p.SetState(5158) p.Expression() } @@ -70557,10 +76308,10 @@ func (s *OrderByClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OrderByClause() (localctx IOrderByClauseContext) { localctx = NewOrderByClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 550, MDLParserRULE_orderByClause) + p.EnterRule(localctx, 588, MDLParserRULE_orderByClause) p.EnterOuterAlt(localctx, 1) { - p.SetState(4731) + p.SetState(5160) p.Match(MDLParserORDER_BY) if p.HasError() { // Recognition error - abort rule @@ -70568,7 +76319,7 @@ func (p *MDLParser) OrderByClause() (localctx IOrderByClauseContext) { } } { - p.SetState(4732) + p.SetState(5161) p.OrderByList() } @@ -70705,15 +76456,15 @@ func (s *OrderByListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OrderByList() (localctx IOrderByListContext) { localctx = NewOrderByListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 552, MDLParserRULE_orderByList) + p.EnterRule(localctx, 590, MDLParserRULE_orderByList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4734) + p.SetState(5163) p.OrderByItem() } - p.SetState(4739) + p.SetState(5168) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -70722,7 +76473,7 @@ func (p *MDLParser) OrderByList() (localctx IOrderByListContext) { for _la == MDLParserCOMMA { { - p.SetState(4735) + p.SetState(5164) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -70730,11 +76481,11 @@ func (p *MDLParser) OrderByList() (localctx IOrderByListContext) { } } { - p.SetState(4736) + p.SetState(5165) p.OrderByItem() } - p.SetState(4741) + p.SetState(5170) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -70849,15 +76600,15 @@ func (s *OrderByItemContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OrderByItem() (localctx IOrderByItemContext) { localctx = NewOrderByItemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 554, MDLParserRULE_orderByItem) + p.EnterRule(localctx, 592, MDLParserRULE_orderByItem) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4742) + p.SetState(5171) p.Expression() } - p.SetState(4744) + p.SetState(5173) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -70866,7 +76617,7 @@ func (p *MDLParser) OrderByItem() (localctx IOrderByItemContext) { if _la == MDLParserASC || _la == MDLParserDESC { { - p.SetState(4743) + p.SetState(5172) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserASC || _la == MDLParserDESC) { @@ -71012,15 +76763,15 @@ func (s *GroupByListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) GroupByList() (localctx IGroupByListContext) { localctx = NewGroupByListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 556, MDLParserRULE_groupByList) + p.EnterRule(localctx, 594, MDLParserRULE_groupByList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4746) + p.SetState(5175) p.Expression() } - p.SetState(4751) + p.SetState(5180) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -71029,7 +76780,7 @@ func (p *MDLParser) GroupByList() (localctx IGroupByListContext) { for _la == MDLParserCOMMA { { - p.SetState(4747) + p.SetState(5176) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -71037,11 +76788,11 @@ func (p *MDLParser) GroupByList() (localctx IGroupByListContext) { } } { - p.SetState(4748) + p.SetState(5177) p.Expression() } - p.SetState(4753) + p.SetState(5182) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -71149,10 +76900,10 @@ func (s *LimitOffsetClauseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { localctx = NewLimitOffsetClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 558, MDLParserRULE_limitOffsetClause) + p.EnterRule(localctx, 596, MDLParserRULE_limitOffsetClause) var _la int - p.SetState(4766) + p.SetState(5195) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -71162,7 +76913,7 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { case MDLParserLIMIT: p.EnterOuterAlt(localctx, 1) { - p.SetState(4754) + p.SetState(5183) p.Match(MDLParserLIMIT) if p.HasError() { // Recognition error - abort rule @@ -71170,14 +76921,14 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { } } { - p.SetState(4755) + p.SetState(5184) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4758) + p.SetState(5187) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -71186,7 +76937,7 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { if _la == MDLParserOFFSET { { - p.SetState(4756) + p.SetState(5185) p.Match(MDLParserOFFSET) if p.HasError() { // Recognition error - abort rule @@ -71194,7 +76945,7 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { } } { - p.SetState(4757) + p.SetState(5186) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -71207,7 +76958,7 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { case MDLParserOFFSET: p.EnterOuterAlt(localctx, 2) { - p.SetState(4760) + p.SetState(5189) p.Match(MDLParserOFFSET) if p.HasError() { // Recognition error - abort rule @@ -71215,14 +76966,14 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { } } { - p.SetState(4761) + p.SetState(5190) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4764) + p.SetState(5193) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -71231,7 +76982,7 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { if _la == MDLParserLIMIT { { - p.SetState(4762) + p.SetState(5191) p.Match(MDLParserLIMIT) if p.HasError() { // Recognition error - abort rule @@ -71239,7 +76990,7 @@ func (p *MDLParser) LimitOffsetClause() (localctx ILimitOffsetClauseContext) { } } { - p.SetState(4763) + p.SetState(5192) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -71606,123 +77357,123 @@ func (s *UtilityStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) UtilityStatement() (localctx IUtilityStatementContext) { localctx = NewUtilityStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 560, MDLParserRULE_utilityStatement) - p.SetState(4784) + p.EnterRule(localctx, 598, MDLParserRULE_utilityStatement) + p.SetState(5213) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 546, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 609, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4768) + p.SetState(5197) p.ConnectStatement() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4769) + p.SetState(5198) p.DisconnectStatement() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4770) + p.SetState(5199) p.UpdateStatement() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(4771) + p.SetState(5200) p.CheckStatement() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(4772) + p.SetState(5201) p.BuildStatement() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(4773) + p.SetState(5202) p.ExecuteScriptStatement() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(4774) + p.SetState(5203) p.ExecuteRuntimeStatement() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(4775) + p.SetState(5204) p.LintStatement() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(4776) + p.SetState(5205) p.SearchStatement() } case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(4777) + p.SetState(5206) p.UseSessionStatement() } case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(4778) + p.SetState(5207) p.IntrospectApiStatement() } case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(4779) + p.SetState(5208) p.DebugStatement() } case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(4780) + p.SetState(5209) p.DefineFragmentStatement() } case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(4781) + p.SetState(5210) p.SqlStatement() } case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(4782) + p.SetState(5211) p.ImportStatement() } case 16: p.EnterOuterAlt(localctx, 16) { - p.SetState(4783) + p.SetState(5212) p.HelpStatement() } @@ -71820,10 +77571,10 @@ func (s *SearchStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SearchStatement() (localctx ISearchStatementContext) { localctx = NewSearchStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 562, MDLParserRULE_searchStatement) + p.EnterRule(localctx, 600, MDLParserRULE_searchStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4786) + p.SetState(5215) p.Match(MDLParserSEARCH) if p.HasError() { // Recognition error - abort rule @@ -71831,7 +77582,7 @@ func (p *MDLParser) SearchStatement() (localctx ISearchStatementContext) { } } { - p.SetState(4787) + p.SetState(5216) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -71979,20 +77730,20 @@ func (s *ConnectStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { localctx = NewConnectStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 564, MDLParserRULE_connectStatement) + p.EnterRule(localctx, 602, MDLParserRULE_connectStatement) var _la int - p.SetState(4812) + p.SetState(5241) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 612, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4789) + p.SetState(5218) p.Match(MDLParserCONNECT) if p.HasError() { // Recognition error - abort rule @@ -72000,7 +77751,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4790) + p.SetState(5219) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -72008,7 +77759,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4791) + p.SetState(5220) p.Match(MDLParserPROJECT) if p.HasError() { // Recognition error - abort rule @@ -72016,14 +77767,14 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4792) + p.SetState(5221) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4795) + p.SetState(5224) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -72032,7 +77783,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { if _la == MDLParserBRANCH { { - p.SetState(4793) + p.SetState(5222) p.Match(MDLParserBRANCH) if p.HasError() { // Recognition error - abort rule @@ -72040,7 +77791,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4794) + p.SetState(5223) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -72050,7 +77801,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } { - p.SetState(4797) + p.SetState(5226) p.Match(MDLParserTOKEN) if p.HasError() { // Recognition error - abort rule @@ -72058,7 +77809,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4798) + p.SetState(5227) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -72069,7 +77820,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4799) + p.SetState(5228) p.Match(MDLParserCONNECT) if p.HasError() { // Recognition error - abort rule @@ -72077,7 +77828,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4800) + p.SetState(5229) p.Match(MDLParserLOCAL) if p.HasError() { // Recognition error - abort rule @@ -72085,7 +77836,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4801) + p.SetState(5230) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -72096,7 +77847,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4802) + p.SetState(5231) p.Match(MDLParserCONNECT) if p.HasError() { // Recognition error - abort rule @@ -72104,7 +77855,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4803) + p.SetState(5232) p.Match(MDLParserRUNTIME) if p.HasError() { // Recognition error - abort rule @@ -72112,7 +77863,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4804) + p.SetState(5233) p.Match(MDLParserHOST) if p.HasError() { // Recognition error - abort rule @@ -72120,7 +77871,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4805) + p.SetState(5234) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -72128,7 +77879,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4806) + p.SetState(5235) p.Match(MDLParserPORT) if p.HasError() { // Recognition error - abort rule @@ -72136,14 +77887,14 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4807) + p.SetState(5236) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4810) + p.SetState(5239) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -72152,7 +77903,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { if _la == MDLParserTOKEN { { - p.SetState(4808) + p.SetState(5237) p.Match(MDLParserTOKEN) if p.HasError() { // Recognition error - abort rule @@ -72160,7 +77911,7 @@ func (p *MDLParser) ConnectStatement() (localctx IConnectStatementContext) { } } { - p.SetState(4809) + p.SetState(5238) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -72259,10 +78010,10 @@ func (s *DisconnectStatementContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) DisconnectStatement() (localctx IDisconnectStatementContext) { localctx = NewDisconnectStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 566, MDLParserRULE_disconnectStatement) + p.EnterRule(localctx, 604, MDLParserRULE_disconnectStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4814) + p.SetState(5243) p.Match(MDLParserDISCONNECT) if p.HasError() { // Recognition error - abort rule @@ -72385,20 +78136,20 @@ func (s *UpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { localctx = NewUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 568, MDLParserRULE_updateStatement) + p.EnterRule(localctx, 606, MDLParserRULE_updateStatement) var _la int - p.SetState(4832) + p.SetState(5261) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 554, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 617, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4816) + p.SetState(5245) p.Match(MDLParserUPDATE) if p.HasError() { // Recognition error - abort rule @@ -72409,7 +78160,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4817) + p.SetState(5246) p.Match(MDLParserREFRESH) if p.HasError() { // Recognition error - abort rule @@ -72417,14 +78168,14 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { } } { - p.SetState(4818) + p.SetState(5247) p.Match(MDLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4820) + p.SetState(5249) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -72433,7 +78184,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { if _la == MDLParserFULL { { - p.SetState(4819) + p.SetState(5248) p.Match(MDLParserFULL) if p.HasError() { // Recognition error - abort rule @@ -72442,7 +78193,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { } } - p.SetState(4823) + p.SetState(5252) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -72451,7 +78202,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { if _la == MDLParserSOURCE_KW { { - p.SetState(4822) + p.SetState(5251) p.Match(MDLParserSOURCE_KW) if p.HasError() { // Recognition error - abort rule @@ -72460,7 +78211,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { } } - p.SetState(4826) + p.SetState(5255) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -72469,7 +78220,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { if _la == MDLParserFORCE { { - p.SetState(4825) + p.SetState(5254) p.Match(MDLParserFORCE) if p.HasError() { // Recognition error - abort rule @@ -72478,7 +78229,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { } } - p.SetState(4829) + p.SetState(5258) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -72487,7 +78238,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { if _la == MDLParserBACKGROUND { { - p.SetState(4828) + p.SetState(5257) p.Match(MDLParserBACKGROUND) if p.HasError() { // Recognition error - abort rule @@ -72500,7 +78251,7 @@ func (p *MDLParser) UpdateStatement() (localctx IUpdateStatementContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4831) + p.SetState(5260) p.Match(MDLParserREFRESH) if p.HasError() { // Recognition error - abort rule @@ -72597,10 +78348,10 @@ func (s *CheckStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CheckStatement() (localctx ICheckStatementContext) { localctx = NewCheckStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 570, MDLParserRULE_checkStatement) + p.EnterRule(localctx, 608, MDLParserRULE_checkStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4834) + p.SetState(5263) p.Match(MDLParserCHECK) if p.HasError() { // Recognition error - abort rule @@ -72693,10 +78444,10 @@ func (s *BuildStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) BuildStatement() (localctx IBuildStatementContext) { localctx = NewBuildStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 572, MDLParserRULE_buildStatement) + p.EnterRule(localctx, 610, MDLParserRULE_buildStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4836) + p.SetState(5265) p.Match(MDLParserBUILD) if p.HasError() { // Recognition error - abort rule @@ -72799,10 +78550,10 @@ func (s *ExecuteScriptStatementContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatementContext) { localctx = NewExecuteScriptStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 574, MDLParserRULE_executeScriptStatement) + p.EnterRule(localctx, 612, MDLParserRULE_executeScriptStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4838) + p.SetState(5267) p.Match(MDLParserEXECUTE) if p.HasError() { // Recognition error - abort rule @@ -72810,7 +78561,7 @@ func (p *MDLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatementCo } } { - p.SetState(4839) + p.SetState(5268) p.Match(MDLParserSCRIPT) if p.HasError() { // Recognition error - abort rule @@ -72818,7 +78569,7 @@ func (p *MDLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatementCo } } { - p.SetState(4840) + p.SetState(5269) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -72921,10 +78672,10 @@ func (s *ExecuteRuntimeStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) ExecuteRuntimeStatement() (localctx IExecuteRuntimeStatementContext) { localctx = NewExecuteRuntimeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 576, MDLParserRULE_executeRuntimeStatement) + p.EnterRule(localctx, 614, MDLParserRULE_executeRuntimeStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4842) + p.SetState(5271) p.Match(MDLParserEXECUTE) if p.HasError() { // Recognition error - abort rule @@ -72932,7 +78683,7 @@ func (p *MDLParser) ExecuteRuntimeStatement() (localctx IExecuteRuntimeStatement } } { - p.SetState(4843) + p.SetState(5272) p.Match(MDLParserRUNTIME) if p.HasError() { // Recognition error - abort rule @@ -72940,7 +78691,7 @@ func (p *MDLParser) ExecuteRuntimeStatement() (localctx IExecuteRuntimeStatement } } { - p.SetState(4844) + p.SetState(5273) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -73082,10 +78833,10 @@ func (s *LintStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LintStatement() (localctx ILintStatementContext) { localctx = NewLintStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 578, MDLParserRULE_lintStatement) + p.EnterRule(localctx, 616, MDLParserRULE_lintStatement) var _la int - p.SetState(4857) + p.SetState(5286) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -73095,26 +78846,26 @@ func (p *MDLParser) LintStatement() (localctx ILintStatementContext) { case MDLParserLINT: p.EnterOuterAlt(localctx, 1) { - p.SetState(4846) + p.SetState(5275) p.Match(MDLParserLINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4848) + p.SetState(5277) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) == 1 { { - p.SetState(4847) + p.SetState(5276) p.LintTarget() } } else if p.HasError() { // JIM goto errorExit } - p.SetState(4852) + p.SetState(5281) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -73123,7 +78874,7 @@ func (p *MDLParser) LintStatement() (localctx ILintStatementContext) { if _la == MDLParserFORMAT { { - p.SetState(4850) + p.SetState(5279) p.Match(MDLParserFORMAT) if p.HasError() { // Recognition error - abort rule @@ -73131,7 +78882,7 @@ func (p *MDLParser) LintStatement() (localctx ILintStatementContext) { } } { - p.SetState(4851) + p.SetState(5280) p.LintFormat() } @@ -73140,7 +78891,7 @@ func (p *MDLParser) LintStatement() (localctx ILintStatementContext) { case MDLParserSHOW: p.EnterOuterAlt(localctx, 2) { - p.SetState(4854) + p.SetState(5283) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -73148,7 +78899,7 @@ func (p *MDLParser) LintStatement() (localctx ILintStatementContext) { } } { - p.SetState(4855) + p.SetState(5284) p.Match(MDLParserLINT) if p.HasError() { // Recognition error - abort rule @@ -73156,7 +78907,7 @@ func (p *MDLParser) LintStatement() (localctx ILintStatementContext) { } } { - p.SetState(4856) + p.SetState(5285) p.Match(MDLParserRULES) if p.HasError() { // Recognition error - abort rule @@ -73276,22 +79027,22 @@ func (s *LintTargetContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LintTarget() (localctx ILintTargetContext) { localctx = NewLintTargetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 580, MDLParserRULE_lintTarget) - p.SetState(4865) + p.EnterRule(localctx, 618, MDLParserRULE_lintTarget) + p.SetState(5294) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 558, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4859) + p.SetState(5288) p.QualifiedName() } { - p.SetState(4860) + p.SetState(5289) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule @@ -73299,7 +79050,7 @@ func (p *MDLParser) LintTarget() (localctx ILintTargetContext) { } } { - p.SetState(4861) + p.SetState(5290) p.Match(MDLParserSTAR) if p.HasError() { // Recognition error - abort rule @@ -73310,14 +79061,14 @@ func (p *MDLParser) LintTarget() (localctx ILintTargetContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4863) + p.SetState(5292) p.QualifiedName() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(4864) + p.SetState(5293) p.Match(MDLParserSTAR) if p.HasError() { // Recognition error - abort rule @@ -73424,12 +79175,12 @@ func (s *LintFormatContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LintFormat() (localctx ILintFormatContext) { localctx = NewLintFormatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 582, MDLParserRULE_lintFormat) + p.EnterRule(localctx, 620, MDLParserRULE_lintFormat) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4867) + p.SetState(5296) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserJSON || _la == MDLParserTEXT || _la == MDLParserSARIF) { @@ -73547,18 +79298,18 @@ func (s *UseSessionStatementContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) UseSessionStatement() (localctx IUseSessionStatementContext) { localctx = NewUseSessionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 584, MDLParserRULE_useSessionStatement) - p.SetState(4873) + p.EnterRule(localctx, 622, MDLParserRULE_useSessionStatement) + p.SetState(5302) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 559, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(4869) + p.SetState(5298) p.Match(MDLParserUSE) if p.HasError() { // Recognition error - abort rule @@ -73566,14 +79317,14 @@ func (p *MDLParser) UseSessionStatement() (localctx IUseSessionStatementContext) } } { - p.SetState(4870) + p.SetState(5299) p.SessionIdList() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(4871) + p.SetState(5300) p.Match(MDLParserUSE) if p.HasError() { // Recognition error - abort rule @@ -73581,7 +79332,7 @@ func (p *MDLParser) UseSessionStatement() (localctx IUseSessionStatementContext) } } { - p.SetState(4872) + p.SetState(5301) p.Match(MDLParserALL) if p.HasError() { // Recognition error - abort rule @@ -73726,15 +79477,15 @@ func (s *SessionIdListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SessionIdList() (localctx ISessionIdListContext) { localctx = NewSessionIdListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 586, MDLParserRULE_sessionIdList) + p.EnterRule(localctx, 624, MDLParserRULE_sessionIdList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4875) + p.SetState(5304) p.SessionId() } - p.SetState(4880) + p.SetState(5309) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -73743,7 +79494,7 @@ func (p *MDLParser) SessionIdList() (localctx ISessionIdListContext) { for _la == MDLParserCOMMA { { - p.SetState(4876) + p.SetState(5305) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -73751,11 +79502,11 @@ func (p *MDLParser) SessionIdList() (localctx ISessionIdListContext) { } } { - p.SetState(4877) + p.SetState(5306) p.SessionId() } - p.SetState(4882) + p.SetState(5311) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -73853,12 +79604,12 @@ func (s *SessionIdContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SessionId() (localctx ISessionIdContext) { localctx = NewSessionIdContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 588, MDLParserRULE_sessionId) + p.EnterRule(localctx, 626, MDLParserRULE_sessionId) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(4883) + p.SetState(5312) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserIDENTIFIER || _la == MDLParserHYPHENATED_ID) { @@ -73959,10 +79710,10 @@ func (s *IntrospectApiStatementContext) ExitRule(listener antlr.ParseTreeListene func (p *MDLParser) IntrospectApiStatement() (localctx IIntrospectApiStatementContext) { localctx = NewIntrospectApiStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 590, MDLParserRULE_introspectApiStatement) + p.EnterRule(localctx, 628, MDLParserRULE_introspectApiStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4885) + p.SetState(5314) p.Match(MDLParserINTROSPECT) if p.HasError() { // Recognition error - abort rule @@ -73970,7 +79721,7 @@ func (p *MDLParser) IntrospectApiStatement() (localctx IIntrospectApiStatementCo } } { - p.SetState(4886) + p.SetState(5315) p.Match(MDLParserAPI) if p.HasError() { // Recognition error - abort rule @@ -74068,10 +79819,10 @@ func (s *DebugStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DebugStatement() (localctx IDebugStatementContext) { localctx = NewDebugStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 592, MDLParserRULE_debugStatement) + p.EnterRule(localctx, 630, MDLParserRULE_debugStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(4888) + p.SetState(5317) p.Match(MDLParserDEBUG) if p.HasError() { // Recognition error - abort rule @@ -74079,7 +79830,7 @@ func (p *MDLParser) DebugStatement() (localctx IDebugStatementContext) { } } { - p.SetState(4889) + p.SetState(5318) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -74563,21 +80314,21 @@ func (s *SqlGenerateConnectorContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { localctx = NewSqlStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 594, MDLParserRULE_sqlStatement) + p.EnterRule(localctx, 632, MDLParserRULE_sqlStatement) var _la int - p.SetState(4950) + p.SetState(5379) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 566, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 629, p.GetParserRuleContext()) { case 1: localctx = NewSqlConnectContext(p, localctx) p.EnterOuterAlt(localctx, 1) { - p.SetState(4891) + p.SetState(5320) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -74585,7 +80336,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4892) + p.SetState(5321) p.Match(MDLParserCONNECT) if p.HasError() { // Recognition error - abort rule @@ -74593,7 +80344,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4893) + p.SetState(5322) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74601,7 +80352,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4894) + p.SetState(5323) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -74609,7 +80360,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4895) + p.SetState(5324) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -74617,7 +80368,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4896) + p.SetState(5325) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74629,7 +80380,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { localctx = NewSqlDisconnectContext(p, localctx) p.EnterOuterAlt(localctx, 2) { - p.SetState(4897) + p.SetState(5326) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -74637,7 +80388,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4898) + p.SetState(5327) p.Match(MDLParserDISCONNECT) if p.HasError() { // Recognition error - abort rule @@ -74645,7 +80396,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4899) + p.SetState(5328) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74657,7 +80408,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { localctx = NewSqlConnectionsContext(p, localctx) p.EnterOuterAlt(localctx, 3) { - p.SetState(4900) + p.SetState(5329) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -74665,7 +80416,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4901) + p.SetState(5330) p.Match(MDLParserCONNECTIONS) if p.HasError() { // Recognition error - abort rule @@ -74677,7 +80428,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { localctx = NewSqlShowTablesContext(p, localctx) p.EnterOuterAlt(localctx, 4) { - p.SetState(4902) + p.SetState(5331) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -74685,7 +80436,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4903) + p.SetState(5332) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74693,7 +80444,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4904) + p.SetState(5333) p.Match(MDLParserSHOW) if p.HasError() { // Recognition error - abort rule @@ -74701,7 +80452,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4905) + p.SetState(5334) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74713,7 +80464,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { localctx = NewSqlDescribeTableContext(p, localctx) p.EnterOuterAlt(localctx, 5) { - p.SetState(4906) + p.SetState(5335) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -74721,7 +80472,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4907) + p.SetState(5336) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74729,7 +80480,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4908) + p.SetState(5337) p.Match(MDLParserDESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -74737,7 +80488,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4909) + p.SetState(5338) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74749,7 +80500,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { localctx = NewSqlGenerateConnectorContext(p, localctx) p.EnterOuterAlt(localctx, 6) { - p.SetState(4910) + p.SetState(5339) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -74757,7 +80508,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4911) + p.SetState(5340) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74765,7 +80516,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4912) + p.SetState(5341) p.Match(MDLParserGENERATE) if p.HasError() { // Recognition error - abort rule @@ -74773,7 +80524,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4913) + p.SetState(5342) p.Match(MDLParserCONNECTOR) if p.HasError() { // Recognition error - abort rule @@ -74781,7 +80532,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4914) + p.SetState(5343) p.Match(MDLParserINTO) if p.HasError() { // Recognition error - abort rule @@ -74789,10 +80540,10 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4915) + p.SetState(5344) p.IdentifierOrKeyword() } - p.SetState(4928) + p.SetState(5357) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -74801,7 +80552,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { if _la == MDLParserTABLES { { - p.SetState(4916) + p.SetState(5345) p.Match(MDLParserTABLES) if p.HasError() { // Recognition error - abort rule @@ -74809,7 +80560,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4917) + p.SetState(5346) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -74817,10 +80568,10 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4918) + p.SetState(5347) p.IdentifierOrKeyword() } - p.SetState(4923) + p.SetState(5352) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -74829,7 +80580,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { for _la == MDLParserCOMMA { { - p.SetState(4919) + p.SetState(5348) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -74837,11 +80588,11 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4920) + p.SetState(5349) p.IdentifierOrKeyword() } - p.SetState(4925) + p.SetState(5354) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -74849,7 +80600,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(4926) + p.SetState(5355) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -74858,7 +80609,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } - p.SetState(4942) + p.SetState(5371) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -74867,7 +80618,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { if _la == MDLParserVIEWS { { - p.SetState(4930) + p.SetState(5359) p.Match(MDLParserVIEWS) if p.HasError() { // Recognition error - abort rule @@ -74875,7 +80626,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4931) + p.SetState(5360) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -74883,10 +80634,10 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4932) + p.SetState(5361) p.IdentifierOrKeyword() } - p.SetState(4937) + p.SetState(5366) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -74895,7 +80646,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { for _la == MDLParserCOMMA { { - p.SetState(4933) + p.SetState(5362) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -74903,11 +80654,11 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4934) + p.SetState(5363) p.IdentifierOrKeyword() } - p.SetState(4939) + p.SetState(5368) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -74915,7 +80666,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(4940) + p.SetState(5369) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -74924,7 +80675,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } - p.SetState(4945) + p.SetState(5374) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -74933,7 +80684,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { if _la == MDLParserEXEC { { - p.SetState(4944) + p.SetState(5373) p.Match(MDLParserEXEC) if p.HasError() { // Recognition error - abort rule @@ -74947,7 +80698,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { localctx = NewSqlQueryContext(p, localctx) p.EnterOuterAlt(localctx, 7) { - p.SetState(4947) + p.SetState(5376) p.Match(MDLParserSQL) if p.HasError() { // Recognition error - abort rule @@ -74955,7 +80706,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4948) + p.SetState(5377) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -74963,7 +80714,7 @@ func (p *MDLParser) SqlStatement() (localctx ISqlStatementContext) { } } { - p.SetState(4949) + p.SetState(5378) p.SqlPassthrough() } @@ -75081,13 +80832,13 @@ func (s *SqlPassthroughContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) SqlPassthrough() (localctx ISqlPassthroughContext) { localctx = NewSqlPassthroughContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 596, MDLParserRULE_sqlPassthrough) + p.EnterRule(localctx, 634, MDLParserRULE_sqlPassthrough) var _la int var _alt int p.EnterOuterAlt(localctx, 1) - p.SetState(4953) + p.SetState(5382) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75097,7 +80848,7 @@ func (p *MDLParser) SqlPassthrough() (localctx ISqlPassthroughContext) { switch _alt { case 1: { - p.SetState(4952) + p.SetState(5381) _la = p.GetTokenStream().LA(1) if _la <= 0 || _la == MDLParserEOF || _la == MDLParserSLASH || _la == MDLParserSEMICOLON { @@ -75113,9 +80864,9 @@ func (p *MDLParser) SqlPassthrough() (localctx ISqlPassthroughContext) { goto errorExit } - p.SetState(4955) + p.SetState(5384) p.GetErrorHandler().Sync(p) - _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) if p.HasError() { goto errorExit } @@ -75406,13 +81157,13 @@ func (s *ImportFromQueryContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { localctx = NewImportStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 598, MDLParserRULE_importStatement) + p.EnterRule(localctx, 636, MDLParserRULE_importStatement) var _la int localctx = NewImportFromQueryContext(p, localctx) p.EnterOuterAlt(localctx, 1) { - p.SetState(4957) + p.SetState(5386) p.Match(MDLParserIMPORT) if p.HasError() { // Recognition error - abort rule @@ -75420,7 +81171,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4958) + p.SetState(5387) p.Match(MDLParserFROM) if p.HasError() { // Recognition error - abort rule @@ -75428,11 +81179,11 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4959) + p.SetState(5388) p.IdentifierOrKeyword() } { - p.SetState(4960) + p.SetState(5389) p.Match(MDLParserQUERY) if p.HasError() { // Recognition error - abort rule @@ -75440,7 +81191,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4961) + p.SetState(5390) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserSTRING_LITERAL || _la == MDLParserDOLLAR_STRING) { @@ -75451,7 +81202,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4962) + p.SetState(5391) p.Match(MDLParserINTO) if p.HasError() { // Recognition error - abort rule @@ -75459,11 +81210,11 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4963) + p.SetState(5392) p.QualifiedName() } { - p.SetState(4964) + p.SetState(5393) p.Match(MDLParserMAP) if p.HasError() { // Recognition error - abort rule @@ -75471,7 +81222,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4965) + p.SetState(5394) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -75479,10 +81230,10 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4966) + p.SetState(5395) p.ImportMapping() } - p.SetState(4971) + p.SetState(5400) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75491,7 +81242,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { for _la == MDLParserCOMMA { { - p.SetState(4967) + p.SetState(5396) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -75499,11 +81250,11 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4968) + p.SetState(5397) p.ImportMapping() } - p.SetState(4973) + p.SetState(5402) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75511,14 +81262,14 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(4974) + p.SetState(5403) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(4987) + p.SetState(5416) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75527,7 +81278,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { if _la == MDLParserLINK { { - p.SetState(4975) + p.SetState(5404) p.Match(MDLParserLINK) if p.HasError() { // Recognition error - abort rule @@ -75535,7 +81286,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4976) + p.SetState(5405) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -75543,10 +81294,10 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4977) + p.SetState(5406) p.LinkMapping() } - p.SetState(4982) + p.SetState(5411) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75555,7 +81306,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { for _la == MDLParserCOMMA { { - p.SetState(4978) + p.SetState(5407) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -75563,11 +81314,11 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4979) + p.SetState(5408) p.LinkMapping() } - p.SetState(4984) + p.SetState(5413) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75575,7 +81326,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(4985) + p.SetState(5414) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -75584,7 +81335,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } - p.SetState(4991) + p.SetState(5420) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75593,7 +81344,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { if _la == MDLParserBATCH { { - p.SetState(4989) + p.SetState(5418) p.Match(MDLParserBATCH) if p.HasError() { // Recognition error - abort rule @@ -75601,7 +81352,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4990) + p.SetState(5419) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -75610,7 +81361,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } - p.SetState(4995) + p.SetState(5424) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -75619,7 +81370,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { if _la == MDLParserLIMIT { { - p.SetState(4993) + p.SetState(5422) p.Match(MDLParserLIMIT) if p.HasError() { // Recognition error - abort rule @@ -75627,7 +81378,7 @@ func (p *MDLParser) ImportStatement() (localctx IImportStatementContext) { } } { - p.SetState(4994) + p.SetState(5423) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -75765,14 +81516,14 @@ func (s *ImportMappingContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ImportMapping() (localctx IImportMappingContext) { localctx = NewImportMappingContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 600, MDLParserRULE_importMapping) + p.EnterRule(localctx, 638, MDLParserRULE_importMapping) p.EnterOuterAlt(localctx, 1) { - p.SetState(4997) + p.SetState(5426) p.IdentifierOrKeyword() } { - p.SetState(4998) + p.SetState(5427) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -75780,7 +81531,7 @@ func (p *MDLParser) ImportMapping() (localctx IImportMappingContext) { } } { - p.SetState(4999) + p.SetState(5428) p.IdentifierOrKeyword() } @@ -76007,23 +81758,23 @@ func (s *LinkLookupContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) LinkMapping() (localctx ILinkMappingContext) { localctx = NewLinkMappingContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 602, MDLParserRULE_linkMapping) - p.SetState(5011) + p.EnterRule(localctx, 640, MDLParserRULE_linkMapping) + p.SetState(5440) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 573, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 636, p.GetParserRuleContext()) { case 1: localctx = NewLinkLookupContext(p, localctx) p.EnterOuterAlt(localctx, 1) { - p.SetState(5001) + p.SetState(5430) p.IdentifierOrKeyword() } { - p.SetState(5002) + p.SetState(5431) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -76031,11 +81782,11 @@ func (p *MDLParser) LinkMapping() (localctx ILinkMappingContext) { } } { - p.SetState(5003) + p.SetState(5432) p.IdentifierOrKeyword() } { - p.SetState(5004) + p.SetState(5433) p.Match(MDLParserON) if p.HasError() { // Recognition error - abort rule @@ -76043,7 +81794,7 @@ func (p *MDLParser) LinkMapping() (localctx ILinkMappingContext) { } } { - p.SetState(5005) + p.SetState(5434) p.IdentifierOrKeyword() } @@ -76051,11 +81802,11 @@ func (p *MDLParser) LinkMapping() (localctx ILinkMappingContext) { localctx = NewLinkDirectContext(p, localctx) p.EnterOuterAlt(localctx, 2) { - p.SetState(5007) + p.SetState(5436) p.IdentifierOrKeyword() } { - p.SetState(5008) + p.SetState(5437) p.Match(MDLParserTO) if p.HasError() { // Recognition error - abort rule @@ -76063,7 +81814,7 @@ func (p *MDLParser) LinkMapping() (localctx ILinkMappingContext) { } } { - p.SetState(5009) + p.SetState(5438) p.IdentifierOrKeyword() } @@ -76156,10 +81907,10 @@ func (s *HelpStatementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) HelpStatement() (localctx IHelpStatementContext) { localctx = NewHelpStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 604, MDLParserRULE_helpStatement) + p.EnterRule(localctx, 642, MDLParserRULE_helpStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(5013) + p.SetState(5442) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -76306,10 +82057,10 @@ func (s *DefineFragmentStatementContext) ExitRule(listener antlr.ParseTreeListen func (p *MDLParser) DefineFragmentStatement() (localctx IDefineFragmentStatementContext) { localctx = NewDefineFragmentStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 606, MDLParserRULE_defineFragmentStatement) + p.EnterRule(localctx, 644, MDLParserRULE_defineFragmentStatement) p.EnterOuterAlt(localctx, 1) { - p.SetState(5015) + p.SetState(5444) p.Match(MDLParserDEFINE) if p.HasError() { // Recognition error - abort rule @@ -76317,7 +82068,7 @@ func (p *MDLParser) DefineFragmentStatement() (localctx IDefineFragmentStatement } } { - p.SetState(5016) + p.SetState(5445) p.Match(MDLParserFRAGMENT) if p.HasError() { // Recognition error - abort rule @@ -76325,11 +82076,11 @@ func (p *MDLParser) DefineFragmentStatement() (localctx IDefineFragmentStatement } } { - p.SetState(5017) + p.SetState(5446) p.IdentifierOrKeyword() } { - p.SetState(5018) + p.SetState(5447) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -76337,7 +82088,7 @@ func (p *MDLParser) DefineFragmentStatement() (localctx IDefineFragmentStatement } } { - p.SetState(5019) + p.SetState(5448) p.Match(MDLParserLBRACE) if p.HasError() { // Recognition error - abort rule @@ -76345,11 +82096,11 @@ func (p *MDLParser) DefineFragmentStatement() (localctx IDefineFragmentStatement } } { - p.SetState(5020) + p.SetState(5449) p.PageBodyV3() } { - p.SetState(5021) + p.SetState(5450) p.Match(MDLParserRBRACE) if p.HasError() { // Recognition error - abort rule @@ -76454,10 +82205,10 @@ func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) Expression() (localctx IExpressionContext) { localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 608, MDLParserRULE_expression) + p.EnterRule(localctx, 646, MDLParserRULE_expression) p.EnterOuterAlt(localctx, 1) { - p.SetState(5023) + p.SetState(5452) p.OrExpression() } @@ -76594,15 +82345,15 @@ func (s *OrExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) OrExpression() (localctx IOrExpressionContext) { localctx = NewOrExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 610, MDLParserRULE_orExpression) + p.EnterRule(localctx, 648, MDLParserRULE_orExpression) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5025) + p.SetState(5454) p.AndExpression() } - p.SetState(5030) + p.SetState(5459) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -76611,7 +82362,7 @@ func (p *MDLParser) OrExpression() (localctx IOrExpressionContext) { for _la == MDLParserOR { { - p.SetState(5026) + p.SetState(5455) p.Match(MDLParserOR) if p.HasError() { // Recognition error - abort rule @@ -76619,11 +82370,11 @@ func (p *MDLParser) OrExpression() (localctx IOrExpressionContext) { } } { - p.SetState(5027) + p.SetState(5456) p.AndExpression() } - p.SetState(5032) + p.SetState(5461) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -76764,15 +82515,15 @@ func (s *AndExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AndExpression() (localctx IAndExpressionContext) { localctx = NewAndExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 612, MDLParserRULE_andExpression) + p.EnterRule(localctx, 650, MDLParserRULE_andExpression) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5033) + p.SetState(5462) p.NotExpression() } - p.SetState(5038) + p.SetState(5467) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -76781,7 +82532,7 @@ func (p *MDLParser) AndExpression() (localctx IAndExpressionContext) { for _la == MDLParserAND { { - p.SetState(5034) + p.SetState(5463) p.Match(MDLParserAND) if p.HasError() { // Recognition error - abort rule @@ -76789,11 +82540,11 @@ func (p *MDLParser) AndExpression() (localctx IAndExpressionContext) { } } { - p.SetState(5035) + p.SetState(5464) p.NotExpression() } - p.SetState(5040) + p.SetState(5469) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -76903,14 +82654,14 @@ func (s *NotExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) NotExpression() (localctx INotExpressionContext) { localctx = NewNotExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 614, MDLParserRULE_notExpression) + p.EnterRule(localctx, 652, MDLParserRULE_notExpression) p.EnterOuterAlt(localctx, 1) - p.SetState(5042) + p.SetState(5471) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 576, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 639, p.GetParserRuleContext()) == 1 { { - p.SetState(5041) + p.SetState(5470) p.Match(MDLParserNOT) if p.HasError() { // Recognition error - abort rule @@ -76922,7 +82673,7 @@ func (p *MDLParser) NotExpression() (localctx INotExpressionContext) { goto errorExit } { - p.SetState(5044) + p.SetState(5473) p.ComparisonExpression() } @@ -77150,32 +82901,32 @@ func (s *ComparisonExpressionContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContext) { localctx = NewComparisonExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 616, MDLParserRULE_comparisonExpression) + p.EnterRule(localctx, 654, MDLParserRULE_comparisonExpression) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5046) + p.SetState(5475) p.AdditiveExpression() } - p.SetState(5075) + p.SetState(5504) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 1 { { - p.SetState(5047) + p.SetState(5476) p.ComparisonOperator() } { - p.SetState(5048) + p.SetState(5477) p.AdditiveExpression() } } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 2 { + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 2 { { - p.SetState(5050) + p.SetState(5479) p.Match(MDLParserIS_NULL) if p.HasError() { // Recognition error - abort rule @@ -77185,9 +82936,9 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 3 { + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 3 { { - p.SetState(5051) + p.SetState(5480) p.Match(MDLParserIS_NOT_NULL) if p.HasError() { // Recognition error - abort rule @@ -77197,9 +82948,9 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 4 { + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 4 { { - p.SetState(5052) + p.SetState(5481) p.Match(MDLParserIN) if p.HasError() { // Recognition error - abort rule @@ -77207,29 +82958,29 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } } { - p.SetState(5053) + p.SetState(5482) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(5056) + p.SetState(5485) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 577, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) { case 1: { - p.SetState(5054) + p.SetState(5483) p.OqlQuery() } case 2: { - p.SetState(5055) + p.SetState(5484) p.ExpressionList() } @@ -77237,7 +82988,7 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex goto errorExit } { - p.SetState(5058) + p.SetState(5487) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -77247,8 +82998,8 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 5 { - p.SetState(5061) + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 5 { + p.SetState(5490) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -77257,7 +83008,7 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex if _la == MDLParserNOT { { - p.SetState(5060) + p.SetState(5489) p.Match(MDLParserNOT) if p.HasError() { // Recognition error - abort rule @@ -77267,7 +83018,7 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } { - p.SetState(5063) + p.SetState(5492) p.Match(MDLParserBETWEEN) if p.HasError() { // Recognition error - abort rule @@ -77275,11 +83026,11 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } } { - p.SetState(5064) + p.SetState(5493) p.AdditiveExpression() } { - p.SetState(5065) + p.SetState(5494) p.Match(MDLParserAND) if p.HasError() { // Recognition error - abort rule @@ -77287,14 +83038,14 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } } { - p.SetState(5066) + p.SetState(5495) p.AdditiveExpression() } } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 6 { - p.SetState(5069) + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 6 { + p.SetState(5498) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -77303,7 +83054,7 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex if _la == MDLParserNOT { { - p.SetState(5068) + p.SetState(5497) p.Match(MDLParserNOT) if p.HasError() { // Recognition error - abort rule @@ -77313,7 +83064,7 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } { - p.SetState(5071) + p.SetState(5500) p.Match(MDLParserLIKE) if p.HasError() { // Recognition error - abort rule @@ -77321,15 +83072,15 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } } { - p.SetState(5072) + p.SetState(5501) p.AdditiveExpression() } } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 7 { + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 7 { { - p.SetState(5073) + p.SetState(5502) p.Match(MDLParserMATCH) if p.HasError() { // Recognition error - abort rule @@ -77337,7 +83088,7 @@ func (p *MDLParser) ComparisonExpression() (localctx IComparisonExpressionContex } } { - p.SetState(5074) + p.SetState(5503) p.AdditiveExpression() } @@ -77455,15 +83206,15 @@ func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ComparisonOperator() (localctx IComparisonOperatorContext) { localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 618, MDLParserRULE_comparisonOperator) + p.EnterRule(localctx, 656, MDLParserRULE_comparisonOperator) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5077) + p.SetState(5506) _la = p.GetTokenStream().LA(1) - if !((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&63) != 0) { + if !((int64((_la-469)) & ^0x3f) == 0 && ((int64(1)<<(_la-469))&63) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -77614,15 +83365,15 @@ func (s *AdditiveExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AdditiveExpression() (localctx IAdditiveExpressionContext) { localctx = NewAdditiveExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 620, MDLParserRULE_additiveExpression) + p.EnterRule(localctx, 658, MDLParserRULE_additiveExpression) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5079) + p.SetState(5508) p.MultiplicativeExpression() } - p.SetState(5084) + p.SetState(5513) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -77631,7 +83382,7 @@ func (p *MDLParser) AdditiveExpression() (localctx IAdditiveExpressionContext) { for _la == MDLParserPLUS || _la == MDLParserMINUS { { - p.SetState(5080) + p.SetState(5509) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserPLUS || _la == MDLParserMINUS) { @@ -77642,11 +83393,11 @@ func (p *MDLParser) AdditiveExpression() (localctx IAdditiveExpressionContext) { } } { - p.SetState(5081) + p.SetState(5510) p.MultiplicativeExpression() } - p.SetState(5086) + p.SetState(5515) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -77837,32 +83588,32 @@ func (s *MultiplicativeExpressionContext) ExitRule(listener antlr.ParseTreeListe func (p *MDLParser) MultiplicativeExpression() (localctx IMultiplicativeExpressionContext) { localctx = NewMultiplicativeExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 622, MDLParserRULE_multiplicativeExpression) + p.EnterRule(localctx, 660, MDLParserRULE_multiplicativeExpression) var _la int var _alt int p.EnterOuterAlt(localctx, 1) { - p.SetState(5087) + p.SetState(5516) p.UnaryExpression() } - p.SetState(5092) + p.SetState(5521) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 582, p.GetParserRuleContext()) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 645, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { - p.SetState(5088) + p.SetState(5517) _la = p.GetTokenStream().LA(1) - if !((int64((_la-456)) & ^0x3f) == 0 && ((int64(1)<<(_la-456))&16415) != 0) { + if !((int64((_la-477)) & ^0x3f) == 0 && ((int64(1)<<(_la-477))&16415) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -77870,17 +83621,17 @@ func (p *MDLParser) MultiplicativeExpression() (localctx IMultiplicativeExpressi } } { - p.SetState(5089) + p.SetState(5518) p.UnaryExpression() } } - p.SetState(5094) + p.SetState(5523) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 582, p.GetParserRuleContext()) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 645, p.GetParserRuleContext()) if p.HasError() { goto errorExit } @@ -77993,11 +83744,11 @@ func (s *UnaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) UnaryExpression() (localctx IUnaryExpressionContext) { localctx = NewUnaryExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 624, MDLParserRULE_unaryExpression) + p.EnterRule(localctx, 662, MDLParserRULE_unaryExpression) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(5096) + p.SetState(5525) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -78006,7 +83757,7 @@ func (p *MDLParser) UnaryExpression() (localctx IUnaryExpressionContext) { if _la == MDLParserPLUS || _la == MDLParserMINUS { { - p.SetState(5095) + p.SetState(5524) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserPLUS || _la == MDLParserMINUS) { @@ -78019,7 +83770,7 @@ func (p *MDLParser) UnaryExpression() (localctx IUnaryExpressionContext) { } { - p.SetState(5098) + p.SetState(5527) p.PrimaryExpression() } @@ -78271,18 +84022,18 @@ func (s *PrimaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { localctx = NewPrimaryExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 626, MDLParserRULE_primaryExpression) - p.SetState(5120) + p.EnterRule(localctx, 664, MDLParserRULE_primaryExpression) + p.SetState(5549) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 584, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 647, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(5100) + p.SetState(5529) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -78290,11 +84041,11 @@ func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { } } { - p.SetState(5101) + p.SetState(5530) p.Expression() } { - p.SetState(5102) + p.SetState(5531) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -78305,7 +84056,7 @@ func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(5104) + p.SetState(5533) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -78313,11 +84064,11 @@ func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { } } { - p.SetState(5105) + p.SetState(5534) p.OqlQuery() } { - p.SetState(5106) + p.SetState(5535) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -78328,7 +84079,7 @@ func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(5108) + p.SetState(5537) p.Match(MDLParserEXISTS) if p.HasError() { // Recognition error - abort rule @@ -78336,7 +84087,7 @@ func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { } } { - p.SetState(5109) + p.SetState(5538) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -78344,11 +84095,11 @@ func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { } } { - p.SetState(5110) + p.SetState(5539) p.OqlQuery() } { - p.SetState(5111) + p.SetState(5540) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -78359,49 +84110,49 @@ func (p *MDLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(5113) + p.SetState(5542) p.CaseExpression() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(5114) + p.SetState(5543) p.CastExpression() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(5115) + p.SetState(5544) p.ListAggregateOperation() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(5116) + p.SetState(5545) p.ListOperation() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(5117) + p.SetState(5546) p.AggregateFunction() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(5118) + p.SetState(5547) p.FunctionCall() } case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(5119) + p.SetState(5548) p.AtomicExpression() } @@ -78567,19 +84318,19 @@ func (s *CaseExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CaseExpression() (localctx ICaseExpressionContext) { localctx = NewCaseExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 628, MDLParserRULE_caseExpression) + p.EnterRule(localctx, 666, MDLParserRULE_caseExpression) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5122) + p.SetState(5551) p.Match(MDLParserCASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(5128) + p.SetState(5557) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -78588,7 +84339,7 @@ func (p *MDLParser) CaseExpression() (localctx ICaseExpressionContext) { for ok := true; ok; ok = _la == MDLParserWHEN { { - p.SetState(5123) + p.SetState(5552) p.Match(MDLParserWHEN) if p.HasError() { // Recognition error - abort rule @@ -78596,11 +84347,11 @@ func (p *MDLParser) CaseExpression() (localctx ICaseExpressionContext) { } } { - p.SetState(5124) + p.SetState(5553) p.Expression() } { - p.SetState(5125) + p.SetState(5554) p.Match(MDLParserTHEN) if p.HasError() { // Recognition error - abort rule @@ -78608,18 +84359,18 @@ func (p *MDLParser) CaseExpression() (localctx ICaseExpressionContext) { } } { - p.SetState(5126) + p.SetState(5555) p.Expression() } - p.SetState(5130) + p.SetState(5559) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(5134) + p.SetState(5563) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -78628,7 +84379,7 @@ func (p *MDLParser) CaseExpression() (localctx ICaseExpressionContext) { if _la == MDLParserELSE { { - p.SetState(5132) + p.SetState(5561) p.Match(MDLParserELSE) if p.HasError() { // Recognition error - abort rule @@ -78636,13 +84387,13 @@ func (p *MDLParser) CaseExpression() (localctx ICaseExpressionContext) { } } { - p.SetState(5133) + p.SetState(5562) p.Expression() } } { - p.SetState(5136) + p.SetState(5565) p.Match(MDLParserEND) if p.HasError() { // Recognition error - abort rule @@ -78784,10 +84535,10 @@ func (s *CastExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CastExpression() (localctx ICastExpressionContext) { localctx = NewCastExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 630, MDLParserRULE_castExpression) + p.EnterRule(localctx, 668, MDLParserRULE_castExpression) p.EnterOuterAlt(localctx, 1) { - p.SetState(5138) + p.SetState(5567) p.Match(MDLParserCAST) if p.HasError() { // Recognition error - abort rule @@ -78795,7 +84546,7 @@ func (p *MDLParser) CastExpression() (localctx ICastExpressionContext) { } } { - p.SetState(5139) + p.SetState(5568) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -78803,11 +84554,11 @@ func (p *MDLParser) CastExpression() (localctx ICastExpressionContext) { } } { - p.SetState(5140) + p.SetState(5569) p.Expression() } { - p.SetState(5141) + p.SetState(5570) p.Match(MDLParserAS) if p.HasError() { // Recognition error - abort rule @@ -78815,11 +84566,11 @@ func (p *MDLParser) CastExpression() (localctx ICastExpressionContext) { } } { - p.SetState(5142) + p.SetState(5571) p.CastDataType() } { - p.SetState(5143) + p.SetState(5572) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -78937,12 +84688,12 @@ func (s *CastDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CastDataType() (localctx ICastDataTypeContext) { localctx = NewCastDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 632, MDLParserRULE_castDataType) + p.EnterRule(localctx, 670, MDLParserRULE_castDataType) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5145) + p.SetState(5574) _la = p.GetTokenStream().LA(1) if !((int64((_la-257)) & ^0x3f) == 0 && ((int64(1)<<(_la-257))&63) != 0) { @@ -79095,12 +84846,12 @@ func (s *AggregateFunctionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AggregateFunction() (localctx IAggregateFunctionContext) { localctx = NewAggregateFunctionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 634, MDLParserRULE_aggregateFunction) + p.EnterRule(localctx, 672, MDLParserRULE_aggregateFunction) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5147) + p.SetState(5576) _la = p.GetTokenStream().LA(1) if !((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&31) != 0) { @@ -79111,27 +84862,27 @@ func (p *MDLParser) AggregateFunction() (localctx IAggregateFunctionContext) { } } { - p.SetState(5148) + p.SetState(5577) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(5154) + p.SetState(5583) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: - p.SetState(5150) + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserCASE, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserHEAD, MDLParserTAIL, MDLParserFIND, MDLParserSORT, MDLParserUNION, MDLParserINTERSECT, MDLParserSUBTRACT, MDLParserCONTAINS, MDLParserAVERAGE, MDLParserMINIMUM, MDLParserMAXIMUM, MDLParserLIST, MDLParserEQUALS_OP, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserEMPTY, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserFILTER, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserLENGTH, MDLParserTRIM, MDLParserCAST, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserEXISTS, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserPLUS, MDLParserMINUS, MDLParserMOD, MDLParserDIV, MDLParserLPAREN, MDLParserMENDIX_TOKEN, MDLParserSTRING_LITERAL, MDLParserNUMBER_LITERAL, MDLParserVARIABLE, MDLParserIDENTIFIER, MDLParserHYPHENATED_ID, MDLParserQUOTED_IDENTIFIER: + p.SetState(5579) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 587, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 650, p.GetParserRuleContext()) == 1 { { - p.SetState(5149) + p.SetState(5578) p.Match(MDLParserDISTINCT) if p.HasError() { // Recognition error - abort rule @@ -79143,13 +84894,13 @@ func (p *MDLParser) AggregateFunction() (localctx IAggregateFunctionContext) { goto errorExit } { - p.SetState(5152) + p.SetState(5581) p.Expression() } case MDLParserSTAR: { - p.SetState(5153) + p.SetState(5582) p.Match(MDLParserSTAR) if p.HasError() { // Recognition error - abort rule @@ -79162,7 +84913,7 @@ func (p *MDLParser) AggregateFunction() (localctx IAggregateFunctionContext) { goto errorExit } { - p.SetState(5156) + p.SetState(5585) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -79294,38 +85045,38 @@ func (s *FunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) FunctionCall() (localctx IFunctionCallContext) { localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 636, MDLParserRULE_functionCall) + p.EnterRule(localctx, 674, MDLParserRULE_functionCall) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5158) + p.SetState(5587) p.FunctionName() } { - p.SetState(5159) + p.SetState(5588) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(5161) + p.SetState(5590) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256446305633024) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-9108493575434249) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1836844262852001929) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&22236590921218055) != 0) || ((int64((_la-257)) & ^0x3f) == 0 && ((int64(1)<<(_la-257))&-213306331643393) != 0) || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&-9007233614479601) != 0) || ((int64((_la-386)) & ^0x3f) == 0 && ((int64(1)<<(_la-386))&4611685824080116567) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2105541731) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256450600600320) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-9108493575434249) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1836844262852001929) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&22236590921218055) != 0) || ((int64((_la-257)) & ^0x3f) == 0 && ((int64(1)<<(_la-257))&-494781308354049) != 0) || ((int64((_la-321)) & ^0x3f) == 0 && ((int64(1)<<(_la-321))&-36028934457918403) != 0) || ((int64((_la-385)) & ^0x3f) == 0 && ((int64(1)<<(_la-385))&-777389085345) != 0) || ((int64((_la-449)) & ^0x3f) == 0 && ((int64(1)<<(_la-449))&141300513672913151) != 0) { { - p.SetState(5160) + p.SetState(5589) p.ArgumentList() } } { - p.SetState(5163) + p.SetState(5592) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -79488,12 +85239,12 @@ func (s *FunctionNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) FunctionName() (localctx IFunctionNameContext) { localctx = NewFunctionNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 638, MDLParserRULE_functionName) + p.EnterRule(localctx, 676, MDLParserRULE_functionName) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5165) + p.SetState(5594) _la = p.GetTokenStream().LA(1) if !(((int64((_la-121)) & ^0x3f) == 0 && ((int64(1)<<(_la-121))&4611686018427519009) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&3145855) != 0) || _la == MDLParserIDENTIFIER || _la == MDLParserHYPHENATED_ID) { @@ -79637,15 +85388,15 @@ func (s *ArgumentListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ArgumentList() (localctx IArgumentListContext) { localctx = NewArgumentListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 640, MDLParserRULE_argumentList) + p.EnterRule(localctx, 678, MDLParserRULE_argumentList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5167) + p.SetState(5596) p.Expression() } - p.SetState(5172) + p.SetState(5601) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -79654,7 +85405,7 @@ func (p *MDLParser) ArgumentList() (localctx IArgumentListContext) { for _la == MDLParserCOMMA { { - p.SetState(5168) + p.SetState(5597) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -79662,11 +85413,11 @@ func (p *MDLParser) ArgumentList() (localctx IArgumentListContext) { } } { - p.SetState(5169) + p.SetState(5598) p.Expression() } - p.SetState(5174) + p.SetState(5603) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -79856,34 +85607,34 @@ func (s *AtomicExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AtomicExpression() (localctx IAtomicExpressionContext) { localctx = NewAtomicExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 642, MDLParserRULE_atomicExpression) + p.EnterRule(localctx, 680, MDLParserRULE_atomicExpression) var _la int - p.SetState(5187) + p.SetState(5616) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 592, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 655, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(5175) + p.SetState(5604) p.Literal() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(5176) + p.SetState(5605) p.Match(MDLParserVARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(5181) + p.SetState(5610) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -79892,7 +85643,7 @@ func (p *MDLParser) AtomicExpression() (localctx IAtomicExpressionContext) { for _la == MDLParserDOT { { - p.SetState(5177) + p.SetState(5606) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule @@ -79900,11 +85651,11 @@ func (p *MDLParser) AtomicExpression() (localctx IAtomicExpressionContext) { } } { - p.SetState(5178) + p.SetState(5607) p.AttributeName() } - p.SetState(5183) + p.SetState(5612) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -79915,14 +85666,14 @@ func (p *MDLParser) AtomicExpression() (localctx IAtomicExpressionContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(5184) + p.SetState(5613) p.QualifiedName() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(5185) + p.SetState(5614) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -79933,7 +85684,7 @@ func (p *MDLParser) AtomicExpression() (localctx IAtomicExpressionContext) { case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(5186) + p.SetState(5615) p.Match(MDLParserMENDIX_TOKEN) if p.HasError() { // Recognition error - abort rule @@ -80078,15 +85829,15 @@ func (s *ExpressionListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ExpressionList() (localctx IExpressionListContext) { localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 644, MDLParserRULE_expressionList) + p.EnterRule(localctx, 682, MDLParserRULE_expressionList) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5189) + p.SetState(5618) p.Expression() } - p.SetState(5194) + p.SetState(5623) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -80095,7 +85846,7 @@ func (p *MDLParser) ExpressionList() (localctx IExpressionListContext) { for _la == MDLParserCOMMA { { - p.SetState(5190) + p.SetState(5619) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -80103,11 +85854,11 @@ func (p *MDLParser) ExpressionList() (localctx IExpressionListContext) { } } { - p.SetState(5191) + p.SetState(5620) p.Expression() } - p.SetState(5196) + p.SetState(5625) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -80248,27 +85999,27 @@ func (s *QualifiedNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) QualifiedName() (localctx IQualifiedNameContext) { localctx = NewQualifiedNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 646, MDLParserRULE_qualifiedName) + p.EnterRule(localctx, 684, MDLParserRULE_qualifiedName) var _alt int p.EnterOuterAlt(localctx, 1) { - p.SetState(5197) + p.SetState(5626) p.IdentifierOrKeyword() } - p.SetState(5202) + p.SetState(5631) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 594, p.GetParserRuleContext()) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 657, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { - p.SetState(5198) + p.SetState(5627) p.Match(MDLParserDOT) if p.HasError() { // Recognition error - abort rule @@ -80276,17 +86027,17 @@ func (p *MDLParser) QualifiedName() (localctx IQualifiedNameContext) { } } { - p.SetState(5199) + p.SetState(5628) p.IdentifierOrKeyword() } } - p.SetState(5204) + p.SetState(5633) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 594, p.GetParserRuleContext()) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 657, p.GetParserRuleContext()) if p.HasError() { goto errorExit } @@ -80399,8 +86150,8 @@ func (s *IdentifierOrKeywordContext) ExitRule(listener antlr.ParseTreeListener) func (p *MDLParser) IdentifierOrKeyword() (localctx IIdentifierOrKeywordContext) { localctx = NewIdentifierOrKeywordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 648, MDLParserRULE_identifierOrKeyword) - p.SetState(5208) + p.EnterRule(localctx, 686, MDLParserRULE_identifierOrKeyword) + p.SetState(5637) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -80410,7 +86161,7 @@ func (p *MDLParser) IdentifierOrKeyword() (localctx IIdentifierOrKeywordContext) case MDLParserIDENTIFIER: p.EnterOuterAlt(localctx, 1) { - p.SetState(5205) + p.SetState(5634) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -80421,7 +86172,7 @@ func (p *MDLParser) IdentifierOrKeyword() (localctx IIdentifierOrKeywordContext) case MDLParserQUOTED_IDENTIFIER: p.EnterOuterAlt(localctx, 2) { - p.SetState(5206) + p.SetState(5635) p.Match(MDLParserQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -80429,10 +86180,10 @@ func (p *MDLParser) IdentifierOrKeyword() (localctx IIdentifierOrKeywordContext) } } - case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: + case MDLParserGROUP_BY, MDLParserORDER_BY, MDLParserCREATE, MDLParserALTER, MDLParserDROP, MDLParserRENAME, MDLParserMOVE, MDLParserENTITY, MDLParserPERSISTENT, MDLParserVIEW, MDLParserEXTERNAL, MDLParserASSOCIATION, MDLParserENUMERATION, MDLParserMODULE, MDLParserMICROFLOW, MDLParserWORKFLOW, MDLParserPAGE, MDLParserSNIPPET, MDLParserLAYOUT, MDLParserATTRIBUTE, MDLParserCOLUMN, MDLParserCOLUMNS, MDLParserINDEX, MDLParserOWNER, MDLParserREFERENCE, MDLParserSET, MDLParserPOSITION, MDLParserSTORAGE, MDLParserTABLE, MDLParserCASCADE, MDLParserCONNECT, MDLParserDISCONNECT, MDLParserLOCAL, MDLParserPROJECT, MDLParserSHOW, MDLParserDESCRIBE, MDLParserUSE, MDLParserDEBUG, MDLParserSELECT, MDLParserFROM, MDLParserWHERE, MDLParserHAVING, MDLParserOFFSET, MDLParserLIMIT, MDLParserAS, MDLParserTHEN, MDLParserELSE, MDLParserEND, MDLParserDISTINCT, MDLParserALL, MDLParserJOIN, MDLParserLEFT, MDLParserRIGHT, MDLParserINNER, MDLParserOUTER, MDLParserON, MDLParserBEGIN, MDLParserDECLARE, MDLParserCHANGE, MDLParserRETRIEVE, MDLParserDELETE, MDLParserCOMMIT, MDLParserLOOP, MDLParserWHILE, MDLParserIF, MDLParserELSIF, MDLParserRETURN, MDLParserLOG, MDLParserCALL, MDLParserJAVA, MDLParserACTION, MDLParserACTIONS, MDLParserCLOSE, MDLParserEVENTS, MDLParserSORT, MDLParserLIST, MDLParserINFO, MDLParserWARNING, MDLParserCRITICAL, MDLParserWITH, MDLParserOBJECT, MDLParserOBJECTS, MDLParserPAGES, MDLParserLAYOUTS, MDLParserSNIPPETS, MDLParserNOTEBOOKS, MDLParserSNIPPETCALL, MDLParserLAYOUTGRID, MDLParserDATAGRID, MDLParserDATAVIEW, MDLParserLISTVIEW, MDLParserGALLERY, MDLParserITEM, MDLParserCONTROLBAR, MDLParserSEARCH, MDLParserSEARCHBAR, MDLParserNAVIGATIONLIST, MDLParserACTIONBUTTON, MDLParserLINKBUTTON, MDLParserBUTTON, MDLParserTITLE, MDLParserDYNAMICTEXT, MDLParserDYNAMIC, MDLParserLABEL, MDLParserTEXTBOX, MDLParserTEXTAREA, MDLParserDATEPICKER, MDLParserRADIOBUTTONS, MDLParserCOMBOBOX, MDLParserCHECKBOX, MDLParserIMAGEINPUT, MDLParserWIDGETS, MDLParserCAPTION, MDLParserDATASOURCE, MDLParserSOURCE_KW, MDLParserSELECTION, MDLParserFOOTER, MDLParserHEADER, MDLParserCONTENT, MDLParserCLASS, MDLParserSTYLE, MDLParserBUTTONSTYLE, MDLParserDESIGN, MDLParserPROPERTIES, MDLParserDESIGNPROPERTIES, MDLParserSTYLING, MDLParserCLEAR, MDLParserWIDTH, MDLParserHEIGHT, MDLParserURL, MDLParserFOLDER, MDLParserCONTEXT, MDLParserEDITABLE, MDLParserIMAGE, MDLParserSTATICIMAGE, MDLParserDYNAMICIMAGE, MDLParserCUSTOMCONTAINER, MDLParserGROUPBOX, MDLParserVISIBLE, MDLParserCANCEL, MDLParserPRIMARY, MDLParserSUCCESS, MDLParserDANGER, MDLParserTEMPLATE, MDLParserSTRING_TYPE, MDLParserINTEGER_TYPE, MDLParserLONG_TYPE, MDLParserDECIMAL_TYPE, MDLParserBOOLEAN_TYPE, MDLParserDATETIME_TYPE, MDLParserDATE_TYPE, MDLParserAUTONUMBER_TYPE, MDLParserBINARY_TYPE, MDLParserCOUNT, MDLParserSUM, MDLParserAVG, MDLParserMIN, MDLParserMAX, MDLParserAND, MDLParserOR, MDLParserNOT, MDLParserNULL, MDLParserIN, MDLParserBETWEEN, MDLParserLIKE, MDLParserUNIQUE, MDLParserDEFAULT, MDLParserTRUE, MDLParserFALSE, MDLParserVALIDATION, MDLParserFEEDBACK, MDLParserRULE, MDLParserREQUIRED, MDLParserERROR, MDLParserRANGE, MDLParserREGEX, MDLParserPATTERN, MDLParserEXPRESSION, MDLParserREST, MDLParserSERVICE, MDLParserSERVICES, MDLParserODATA, MDLParserBASE, MDLParserAUTH, MDLParserAUTHENTICATION, MDLParserBASIC, MDLParserNOTHING, MDLParserOAUTH, MDLParserOPERATION, MDLParserMETHOD, MDLParserPATH, MDLParserTIMEOUT, MDLParserBODY, MDLParserRESPONSE, MDLParserJSON, MDLParserXML, MDLParserSTATUS, MDLParserVERSION, MDLParserAPI, MDLParserCLIENT, MDLParserCLIENTS, MDLParserPUBLISH, MDLParserEXPOSE, MDLParserNAMESPACE_KW, MDLParserSESSION, MDLParserGUEST, MDLParserPAGING, MDLParserNOT_SUPPORTED, MDLParserUSERNAME, MDLParserPASSWORD, MDLParserCONNECTION, MDLParserDATABASE, MDLParserQUERY, MDLParserMAP, MDLParserMAPPING, MDLParserIMPORT, MDLParserINTO, MDLParserBATCH, MDLParserLINK, MDLParserEXPORT, MDLParserGENERATE, MDLParserCONNECTOR, MDLParserEXEC, MDLParserTABLES, MDLParserVIEWS, MDLParserPARAMETER, MDLParserPARAMETERS, MDLParserHEADERS, MDLParserNAVIGATION, MDLParserMENU_KW, MDLParserHOMES, MDLParserHOME, MDLParserLOGIN, MDLParserFOUND, MDLParserMODULES, MDLParserENTITIES, MDLParserASSOCIATIONS, MDLParserMICROFLOWS, MDLParserNANOFLOWS, MDLParserWORKFLOWS, MDLParserENUMERATIONS, MDLParserCONSTANTS, MDLParserDEFINE, MDLParserFRAGMENT, MDLParserFRAGMENTS, MDLParserINSERT, MDLParserBEFORE, MDLParserAFTER, MDLParserUPDATE, MDLParserREFRESH, MDLParserCHECK, MDLParserBUILD, MDLParserEXECUTE, MDLParserSCRIPT, MDLParserLINT, MDLParserTEXT, MDLParserMESSAGE, MDLParserCATALOG, MDLParserFORCE, MDLParserCALLERS, MDLParserCALLEES, MDLParserREFERENCES, MDLParserTRANSITIVE, MDLParserIMPACT, MDLParserDEPTH, MDLParserSTRUCTURE, MDLParserTYPE, MDLParserVALUE, MDLParserSINGLE, MDLParserMULTIPLE, MDLParserNONE, MDLParserBOTH, MDLParserTO, MDLParserOF, MDLParserOVER, MDLParserFOR, MDLParserREPLACE, MDLParserMEMBERS, MDLParserFORMAT, MDLParserWITHOUT, MDLParserWIDGETTYPE, MDLParserBUSINESS, MDLParserEVENT, MDLParserSUBSCRIBE, MDLParserSETTINGS, MDLParserCONFIGURATION, MDLParserSECURITY, MDLParserROLE, MDLParserROLES, MDLParserGRANT, MDLParserREVOKE, MDLParserPRODUCTION, MDLParserPROTOTYPE, MDLParserMANAGE, MDLParserDEMO, MDLParserMATRIX, MDLParserAPPLY, MDLParserACCESS, MDLParserLEVEL, MDLParserUSER, MDLParserTASK, MDLParserDECISION, MDLParserSPLIT, MDLParserOUTCOMES, MDLParserTARGETING, MDLParserNOTIFICATION, MDLParserTIMER, MDLParserJUMP, MDLParserDUE, MDLParserOVERVIEW, MDLParserDATE, MDLParserPARALLEL, MDLParserWAIT, MDLParserBY, MDLParserREAD, MDLParserWRITE, MDLParserDESCRIPTION, MDLParserOFF, MDLParserUSERS, MDLParserMOD, MDLParserDIV: p.EnterOuterAlt(localctx, 3) { - p.SetState(5207) + p.SetState(5636) p.Keyword() } @@ -80558,8 +86309,8 @@ func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) Literal() (localctx ILiteralContext) { localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 650, MDLParserRULE_literal) - p.SetState(5215) + p.EnterRule(localctx, 688, MDLParserRULE_literal) + p.SetState(5644) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -80569,7 +86320,7 @@ func (p *MDLParser) Literal() (localctx ILiteralContext) { case MDLParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 1) { - p.SetState(5210) + p.SetState(5639) p.Match(MDLParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -80580,7 +86331,7 @@ func (p *MDLParser) Literal() (localctx ILiteralContext) { case MDLParserNUMBER_LITERAL: p.EnterOuterAlt(localctx, 2) { - p.SetState(5211) + p.SetState(5640) p.Match(MDLParserNUMBER_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -80591,14 +86342,14 @@ func (p *MDLParser) Literal() (localctx ILiteralContext) { case MDLParserTRUE, MDLParserFALSE: p.EnterOuterAlt(localctx, 3) { - p.SetState(5212) + p.SetState(5641) p.BooleanLiteral() } case MDLParserNULL: p.EnterOuterAlt(localctx, 4) { - p.SetState(5213) + p.SetState(5642) p.Match(MDLParserNULL) if p.HasError() { // Recognition error - abort rule @@ -80609,7 +86360,7 @@ func (p *MDLParser) Literal() (localctx ILiteralContext) { case MDLParserEMPTY: p.EnterOuterAlt(localctx, 5) { - p.SetState(5214) + p.SetState(5643) p.Match(MDLParserEMPTY) if p.HasError() { // Recognition error - abort rule @@ -80765,19 +86516,19 @@ func (s *ArrayLiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) ArrayLiteral() (localctx IArrayLiteralContext) { localctx = NewArrayLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 652, MDLParserRULE_arrayLiteral) + p.EnterRule(localctx, 690, MDLParserRULE_arrayLiteral) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5217) + p.SetState(5646) p.Match(MDLParserLBRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(5226) + p.SetState(5655) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -80786,10 +86537,10 @@ func (p *MDLParser) ArrayLiteral() (localctx IArrayLiteralContext) { if _la == MDLParserEMPTY || ((int64((_la-283)) & ^0x3f) == 0 && ((int64(1)<<(_la-283))&769) != 0) || _la == MDLParserSTRING_LITERAL || _la == MDLParserNUMBER_LITERAL { { - p.SetState(5218) + p.SetState(5647) p.Literal() } - p.SetState(5223) + p.SetState(5652) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -80798,7 +86549,7 @@ func (p *MDLParser) ArrayLiteral() (localctx IArrayLiteralContext) { for _la == MDLParserCOMMA { { - p.SetState(5219) + p.SetState(5648) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -80806,11 +86557,11 @@ func (p *MDLParser) ArrayLiteral() (localctx IArrayLiteralContext) { } } { - p.SetState(5220) + p.SetState(5649) p.Literal() } - p.SetState(5225) + p.SetState(5654) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -80820,7 +86571,7 @@ func (p *MDLParser) ArrayLiteral() (localctx IArrayLiteralContext) { } { - p.SetState(5228) + p.SetState(5657) p.Match(MDLParserRBRACKET) if p.HasError() { // Recognition error - abort rule @@ -80918,12 +86669,12 @@ func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) BooleanLiteral() (localctx IBooleanLiteralContext) { localctx = NewBooleanLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 654, MDLParserRULE_booleanLiteral) + p.EnterRule(localctx, 692, MDLParserRULE_booleanLiteral) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5230) + p.SetState(5659) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserTRUE || _la == MDLParserFALSE) { @@ -81019,10 +86770,10 @@ func (s *DocCommentContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) DocComment() (localctx IDocCommentContext) { localctx = NewDocCommentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 656, MDLParserRULE_docComment) + p.EnterRule(localctx, 694, MDLParserRULE_docComment) p.EnterOuterAlt(localctx, 1) { - p.SetState(5232) + p.SetState(5661) p.Match(MDLParserDOC_COMMENT) if p.HasError() { // Recognition error - abort rule @@ -81176,10 +86927,10 @@ func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) Annotation() (localctx IAnnotationContext) { localctx = NewAnnotationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 658, MDLParserRULE_annotation) + p.EnterRule(localctx, 696, MDLParserRULE_annotation) p.EnterOuterAlt(localctx, 1) { - p.SetState(5234) + p.SetState(5663) p.Match(MDLParserAT) if p.HasError() { // Recognition error - abort rule @@ -81187,15 +86938,15 @@ func (p *MDLParser) Annotation() (localctx IAnnotationContext) { } } { - p.SetState(5235) + p.SetState(5664) p.AnnotationName() } - p.SetState(5241) + p.SetState(5670) p.GetErrorHandler().Sync(p) - if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 599, p.GetParserRuleContext()) == 1 { + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 662, p.GetParserRuleContext()) == 1 { { - p.SetState(5236) + p.SetState(5665) p.Match(MDLParserLPAREN) if p.HasError() { // Recognition error - abort rule @@ -81203,11 +86954,11 @@ func (p *MDLParser) Annotation() (localctx IAnnotationContext) { } } { - p.SetState(5237) + p.SetState(5666) p.AnnotationParams() } { - p.SetState(5238) + p.SetState(5667) p.Match(MDLParserRPAREN) if p.HasError() { // Recognition error - abort rule @@ -81217,9 +86968,9 @@ func (p *MDLParser) Annotation() (localctx IAnnotationContext) { } else if p.HasError() { // JIM goto errorExit - } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 599, p.GetParserRuleContext()) == 2 { + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 662, p.GetParserRuleContext()) == 2 { { - p.SetState(5240) + p.SetState(5669) p.AnnotationValue() } @@ -81342,12 +87093,12 @@ func (s *AnnotationNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AnnotationName() (localctx IAnnotationNameContext) { localctx = NewAnnotationNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 660, MDLParserRULE_annotationName) + p.EnterRule(localctx, 698, MDLParserRULE_annotationName) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5243) + p.SetState(5672) _la = p.GetTokenStream().LA(1) if !(_la == MDLParserPOSITION || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&536870915) != 0) || _la == MDLParserREQUIRED || _la == MDLParserCOMMENT || _la == MDLParserIDENTIFIER) { @@ -81491,15 +87242,15 @@ func (s *AnnotationParamsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AnnotationParams() (localctx IAnnotationParamsContext) { localctx = NewAnnotationParamsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 662, MDLParserRULE_annotationParams) + p.EnterRule(localctx, 700, MDLParserRULE_annotationParams) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5245) + p.SetState(5674) p.AnnotationParam() } - p.SetState(5250) + p.SetState(5679) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -81508,7 +87259,7 @@ func (p *MDLParser) AnnotationParams() (localctx IAnnotationParamsContext) { for _la == MDLParserCOMMA { { - p.SetState(5246) + p.SetState(5675) p.Match(MDLParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -81516,11 +87267,11 @@ func (p *MDLParser) AnnotationParams() (localctx IAnnotationParamsContext) { } } { - p.SetState(5247) + p.SetState(5676) p.AnnotationParam() } - p.SetState(5252) + p.SetState(5681) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -81635,18 +87386,18 @@ func (s *AnnotationParamContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AnnotationParam() (localctx IAnnotationParamContext) { localctx = NewAnnotationParamContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 664, MDLParserRULE_annotationParam) - p.SetState(5257) + p.EnterRule(localctx, 702, MDLParserRULE_annotationParam) + p.SetState(5686) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 601, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 664, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(5253) + p.SetState(5682) p.Match(MDLParserIDENTIFIER) if p.HasError() { // Recognition error - abort rule @@ -81654,7 +87405,7 @@ func (p *MDLParser) AnnotationParam() (localctx IAnnotationParamContext) { } } { - p.SetState(5254) + p.SetState(5683) p.Match(MDLParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -81662,14 +87413,14 @@ func (p *MDLParser) AnnotationParam() (localctx IAnnotationParamContext) { } } { - p.SetState(5255) + p.SetState(5684) p.AnnotationValue() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(5256) + p.SetState(5685) p.AnnotationValue() } @@ -81808,32 +87559,32 @@ func (s *AnnotationValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) AnnotationValue() (localctx IAnnotationValueContext) { localctx = NewAnnotationValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 666, MDLParserRULE_annotationValue) - p.SetState(5262) + p.EnterRule(localctx, 704, MDLParserRULE_annotationValue) + p.SetState(5691) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 665, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(5259) + p.SetState(5688) p.Literal() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(5260) + p.SetState(5689) p.Expression() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(5261) + p.SetState(5690) p.QualifiedName() } @@ -82221,15 +87972,15 @@ func (s *CommonNameKeywordContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) CommonNameKeyword() (localctx ICommonNameKeywordContext) { localctx = NewCommonNameKeywordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 668, MDLParserRULE_commonNameKeyword) + p.EnterRule(localctx, 706, MDLParserRULE_commonNameKeyword) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5264) + p.SetState(5693) _la = p.GetTokenStream().LA(1) - if !(((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&27021598099767327) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&5647091739131907) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&7081394446399) != 0)) { + if !(((int64((_la-41)) & ^0x3f) == 0 && ((int64(1)<<(_la-41))&134223495) != 0) || ((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&4785074609848577) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&72059798262513977) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&54043195863990303) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&5647091739131907) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&5764608007358914623) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -82536,10 +88287,25 @@ type IKeywordContext interface { EVENTS() antlr.TerminalNode OVER() antlr.TerminalNode MEMBERS() antlr.TerminalNode + WORKFLOW() antlr.TerminalNode WORKFLOWS() antlr.TerminalNode REFERENCES() antlr.TerminalNode CALLERS() antlr.TerminalNode CALLEES() antlr.TerminalNode + TASK() antlr.TerminalNode + DECISION() antlr.TerminalNode + SPLIT() antlr.TerminalNode + OUTCOMES() antlr.TerminalNode + TARGETING() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + TIMER() antlr.TerminalNode + JUMP() antlr.TerminalNode + DUE() antlr.TerminalNode + OVERVIEW() antlr.TerminalNode + DATE() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + WAIT() antlr.TerminalNode + BY() antlr.TerminalNode TRANSITIVE() antlr.TerminalNode IMPACT() antlr.TerminalNode SEARCH() antlr.TerminalNode @@ -83713,6 +89479,10 @@ func (s *KeywordContext) MEMBERS() antlr.TerminalNode { return s.GetToken(MDLParserMEMBERS, 0) } +func (s *KeywordContext) WORKFLOW() antlr.TerminalNode { + return s.GetToken(MDLParserWORKFLOW, 0) +} + func (s *KeywordContext) WORKFLOWS() antlr.TerminalNode { return s.GetToken(MDLParserWORKFLOWS, 0) } @@ -83729,6 +89499,62 @@ func (s *KeywordContext) CALLEES() antlr.TerminalNode { return s.GetToken(MDLParserCALLEES, 0) } +func (s *KeywordContext) TASK() antlr.TerminalNode { + return s.GetToken(MDLParserTASK, 0) +} + +func (s *KeywordContext) DECISION() antlr.TerminalNode { + return s.GetToken(MDLParserDECISION, 0) +} + +func (s *KeywordContext) SPLIT() antlr.TerminalNode { + return s.GetToken(MDLParserSPLIT, 0) +} + +func (s *KeywordContext) OUTCOMES() antlr.TerminalNode { + return s.GetToken(MDLParserOUTCOMES, 0) +} + +func (s *KeywordContext) TARGETING() antlr.TerminalNode { + return s.GetToken(MDLParserTARGETING, 0) +} + +func (s *KeywordContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(MDLParserNOTIFICATION, 0) +} + +func (s *KeywordContext) TIMER() antlr.TerminalNode { + return s.GetToken(MDLParserTIMER, 0) +} + +func (s *KeywordContext) JUMP() antlr.TerminalNode { + return s.GetToken(MDLParserJUMP, 0) +} + +func (s *KeywordContext) DUE() antlr.TerminalNode { + return s.GetToken(MDLParserDUE, 0) +} + +func (s *KeywordContext) OVERVIEW() antlr.TerminalNode { + return s.GetToken(MDLParserOVERVIEW, 0) +} + +func (s *KeywordContext) DATE() antlr.TerminalNode { + return s.GetToken(MDLParserDATE, 0) +} + +func (s *KeywordContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(MDLParserPARALLEL, 0) +} + +func (s *KeywordContext) WAIT() antlr.TerminalNode { + return s.GetToken(MDLParserWAIT, 0) +} + +func (s *KeywordContext) BY() antlr.TerminalNode { + return s.GetToken(MDLParserBY, 0) +} + func (s *KeywordContext) TRANSITIVE() antlr.TerminalNode { return s.GetToken(MDLParserTRANSITIVE, 0) } @@ -83847,15 +89673,15 @@ func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) { func (p *MDLParser) Keyword() (localctx IKeywordContext) { localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 670, MDLParserRULE_keyword) + p.EnterRule(localctx, 708, MDLParserRULE_keyword) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(5266) + p.SetState(5695) _la = p.GetTokenStream().LA(1) - if !(((int64((_la-8)) & ^0x3f) == 0 && ((int64(1)<<(_la-8))&-646357188347970045) != 0) || ((int64((_la-72)) & ^0x3f) == 0 && ((int64(1)<<(_la-72))&7206990461134962447) != 0) || ((int64((_la-136)) & ^0x3f) == 0 && ((int64(1)<<(_la-136))&569144841913302523) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&9205368496055704575) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&-541557868210618849) != 0) || ((int64((_la-335)) & ^0x3f) == 0 && ((int64(1)<<(_la-335))&-2684146477428637697) != 0) || ((int64((_la-399)) & ^0x3f) == 0 && ((int64(1)<<(_la-399))&3459327463750238207) != 0)) { + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&553256450600600320) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&315150679595225079) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-468218264967741735) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-9217812889124471295) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-247391730802433) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&-9007233614479601) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-194347271337) != 0) || ((int64((_la-451)) & ^0x3f) == 0 && ((int64(1)<<(_la-451))&1610840127) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) diff --git a/mdl/grammar/parser/mdlparser_base_listener.go b/mdl/grammar/parser/mdlparser_base_listener.go index ce4931e..52bafeb 100644 --- a/mdl/grammar/parser/mdlparser_base_listener.go +++ b/mdl/grammar/parser/mdlparser_base_listener.go @@ -218,6 +218,22 @@ func (s *BaseMDLParserListener) EnterRevokePageAccessStatement(ctx *RevokePageAc func (s *BaseMDLParserListener) ExitRevokePageAccessStatement(ctx *RevokePageAccessStatementContext) { } +// EnterGrantWorkflowAccessStatement is called when production grantWorkflowAccessStatement is entered. +func (s *BaseMDLParserListener) EnterGrantWorkflowAccessStatement(ctx *GrantWorkflowAccessStatementContext) { +} + +// ExitGrantWorkflowAccessStatement is called when production grantWorkflowAccessStatement is exited. +func (s *BaseMDLParserListener) ExitGrantWorkflowAccessStatement(ctx *GrantWorkflowAccessStatementContext) { +} + +// EnterRevokeWorkflowAccessStatement is called when production revokeWorkflowAccessStatement is entered. +func (s *BaseMDLParserListener) EnterRevokeWorkflowAccessStatement(ctx *RevokeWorkflowAccessStatementContext) { +} + +// ExitRevokeWorkflowAccessStatement is called when production revokeWorkflowAccessStatement is exited. +func (s *BaseMDLParserListener) ExitRevokeWorkflowAccessStatement(ctx *RevokeWorkflowAccessStatementContext) { +} + // EnterGrantODataServiceAccessStatement is called when production grantODataServiceAccessStatement is entered. func (s *BaseMDLParserListener) EnterGrantODataServiceAccessStatement(ctx *GrantODataServiceAccessStatementContext) { } @@ -1544,6 +1560,116 @@ func (s *BaseMDLParserListener) EnterBusinessEventAttrDef(ctx *BusinessEventAttr // ExitBusinessEventAttrDef is called when production businessEventAttrDef is exited. func (s *BaseMDLParserListener) ExitBusinessEventAttrDef(ctx *BusinessEventAttrDefContext) {} +// EnterCreateWorkflowStatement is called when production createWorkflowStatement is entered. +func (s *BaseMDLParserListener) EnterCreateWorkflowStatement(ctx *CreateWorkflowStatementContext) {} + +// ExitCreateWorkflowStatement is called when production createWorkflowStatement is exited. +func (s *BaseMDLParserListener) ExitCreateWorkflowStatement(ctx *CreateWorkflowStatementContext) {} + +// EnterWorkflowBody is called when production workflowBody is entered. +func (s *BaseMDLParserListener) EnterWorkflowBody(ctx *WorkflowBodyContext) {} + +// ExitWorkflowBody is called when production workflowBody is exited. +func (s *BaseMDLParserListener) ExitWorkflowBody(ctx *WorkflowBodyContext) {} + +// EnterWorkflowActivityStmt is called when production workflowActivityStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowActivityStmt(ctx *WorkflowActivityStmtContext) {} + +// ExitWorkflowActivityStmt is called when production workflowActivityStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowActivityStmt(ctx *WorkflowActivityStmtContext) {} + +// EnterWorkflowUserTaskStmt is called when production workflowUserTaskStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowUserTaskStmt(ctx *WorkflowUserTaskStmtContext) {} + +// ExitWorkflowUserTaskStmt is called when production workflowUserTaskStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowUserTaskStmt(ctx *WorkflowUserTaskStmtContext) {} + +// EnterWorkflowBoundaryEventClause is called when production workflowBoundaryEventClause is entered. +func (s *BaseMDLParserListener) EnterWorkflowBoundaryEventClause(ctx *WorkflowBoundaryEventClauseContext) { +} + +// ExitWorkflowBoundaryEventClause is called when production workflowBoundaryEventClause is exited. +func (s *BaseMDLParserListener) ExitWorkflowBoundaryEventClause(ctx *WorkflowBoundaryEventClauseContext) { +} + +// EnterWorkflowUserTaskOutcome is called when production workflowUserTaskOutcome is entered. +func (s *BaseMDLParserListener) EnterWorkflowUserTaskOutcome(ctx *WorkflowUserTaskOutcomeContext) {} + +// ExitWorkflowUserTaskOutcome is called when production workflowUserTaskOutcome is exited. +func (s *BaseMDLParserListener) ExitWorkflowUserTaskOutcome(ctx *WorkflowUserTaskOutcomeContext) {} + +// EnterWorkflowCallMicroflowStmt is called when production workflowCallMicroflowStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowCallMicroflowStmt(ctx *WorkflowCallMicroflowStmtContext) { +} + +// ExitWorkflowCallMicroflowStmt is called when production workflowCallMicroflowStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowCallMicroflowStmt(ctx *WorkflowCallMicroflowStmtContext) { +} + +// EnterWorkflowParameterMapping is called when production workflowParameterMapping is entered. +func (s *BaseMDLParserListener) EnterWorkflowParameterMapping(ctx *WorkflowParameterMappingContext) {} + +// ExitWorkflowParameterMapping is called when production workflowParameterMapping is exited. +func (s *BaseMDLParserListener) ExitWorkflowParameterMapping(ctx *WorkflowParameterMappingContext) {} + +// EnterWorkflowCallWorkflowStmt is called when production workflowCallWorkflowStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowCallWorkflowStmt(ctx *WorkflowCallWorkflowStmtContext) {} + +// ExitWorkflowCallWorkflowStmt is called when production workflowCallWorkflowStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowCallWorkflowStmt(ctx *WorkflowCallWorkflowStmtContext) {} + +// EnterWorkflowDecisionStmt is called when production workflowDecisionStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowDecisionStmt(ctx *WorkflowDecisionStmtContext) {} + +// ExitWorkflowDecisionStmt is called when production workflowDecisionStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowDecisionStmt(ctx *WorkflowDecisionStmtContext) {} + +// EnterWorkflowConditionOutcome is called when production workflowConditionOutcome is entered. +func (s *BaseMDLParserListener) EnterWorkflowConditionOutcome(ctx *WorkflowConditionOutcomeContext) {} + +// ExitWorkflowConditionOutcome is called when production workflowConditionOutcome is exited. +func (s *BaseMDLParserListener) ExitWorkflowConditionOutcome(ctx *WorkflowConditionOutcomeContext) {} + +// EnterWorkflowParallelSplitStmt is called when production workflowParallelSplitStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowParallelSplitStmt(ctx *WorkflowParallelSplitStmtContext) { +} + +// ExitWorkflowParallelSplitStmt is called when production workflowParallelSplitStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowParallelSplitStmt(ctx *WorkflowParallelSplitStmtContext) { +} + +// EnterWorkflowParallelPath is called when production workflowParallelPath is entered. +func (s *BaseMDLParserListener) EnterWorkflowParallelPath(ctx *WorkflowParallelPathContext) {} + +// ExitWorkflowParallelPath is called when production workflowParallelPath is exited. +func (s *BaseMDLParserListener) ExitWorkflowParallelPath(ctx *WorkflowParallelPathContext) {} + +// EnterWorkflowJumpToStmt is called when production workflowJumpToStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowJumpToStmt(ctx *WorkflowJumpToStmtContext) {} + +// ExitWorkflowJumpToStmt is called when production workflowJumpToStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowJumpToStmt(ctx *WorkflowJumpToStmtContext) {} + +// EnterWorkflowWaitForTimerStmt is called when production workflowWaitForTimerStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowWaitForTimerStmt(ctx *WorkflowWaitForTimerStmtContext) {} + +// ExitWorkflowWaitForTimerStmt is called when production workflowWaitForTimerStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowWaitForTimerStmt(ctx *WorkflowWaitForTimerStmtContext) {} + +// EnterWorkflowWaitForNotificationStmt is called when production workflowWaitForNotificationStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowWaitForNotificationStmt(ctx *WorkflowWaitForNotificationStmtContext) { +} + +// ExitWorkflowWaitForNotificationStmt is called when production workflowWaitForNotificationStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowWaitForNotificationStmt(ctx *WorkflowWaitForNotificationStmtContext) { +} + +// EnterWorkflowAnnotationStmt is called when production workflowAnnotationStmt is entered. +func (s *BaseMDLParserListener) EnterWorkflowAnnotationStmt(ctx *WorkflowAnnotationStmtContext) {} + +// ExitWorkflowAnnotationStmt is called when production workflowAnnotationStmt is exited. +func (s *BaseMDLParserListener) ExitWorkflowAnnotationStmt(ctx *WorkflowAnnotationStmtContext) {} + // EnterAlterSettingsClause is called when production alterSettingsClause is entered. func (s *BaseMDLParserListener) EnterAlterSettingsClause(ctx *AlterSettingsClauseContext) {} diff --git a/mdl/grammar/parser/mdlparser_listener.go b/mdl/grammar/parser/mdlparser_listener.go index 8dc5d28..d3bd46b 100644 --- a/mdl/grammar/parser/mdlparser_listener.go +++ b/mdl/grammar/parser/mdlparser_listener.go @@ -100,6 +100,12 @@ type MDLParserListener interface { // EnterRevokePageAccessStatement is called when entering the revokePageAccessStatement production. EnterRevokePageAccessStatement(c *RevokePageAccessStatementContext) + // EnterGrantWorkflowAccessStatement is called when entering the grantWorkflowAccessStatement production. + EnterGrantWorkflowAccessStatement(c *GrantWorkflowAccessStatementContext) + + // EnterRevokeWorkflowAccessStatement is called when entering the revokeWorkflowAccessStatement production. + EnterRevokeWorkflowAccessStatement(c *RevokeWorkflowAccessStatementContext) + // EnterGrantODataServiceAccessStatement is called when entering the grantODataServiceAccessStatement production. EnterGrantODataServiceAccessStatement(c *GrantODataServiceAccessStatementContext) @@ -745,6 +751,57 @@ type MDLParserListener interface { // EnterBusinessEventAttrDef is called when entering the businessEventAttrDef production. EnterBusinessEventAttrDef(c *BusinessEventAttrDefContext) + // EnterCreateWorkflowStatement is called when entering the createWorkflowStatement production. + EnterCreateWorkflowStatement(c *CreateWorkflowStatementContext) + + // EnterWorkflowBody is called when entering the workflowBody production. + EnterWorkflowBody(c *WorkflowBodyContext) + + // EnterWorkflowActivityStmt is called when entering the workflowActivityStmt production. + EnterWorkflowActivityStmt(c *WorkflowActivityStmtContext) + + // EnterWorkflowUserTaskStmt is called when entering the workflowUserTaskStmt production. + EnterWorkflowUserTaskStmt(c *WorkflowUserTaskStmtContext) + + // EnterWorkflowBoundaryEventClause is called when entering the workflowBoundaryEventClause production. + EnterWorkflowBoundaryEventClause(c *WorkflowBoundaryEventClauseContext) + + // EnterWorkflowUserTaskOutcome is called when entering the workflowUserTaskOutcome production. + EnterWorkflowUserTaskOutcome(c *WorkflowUserTaskOutcomeContext) + + // EnterWorkflowCallMicroflowStmt is called when entering the workflowCallMicroflowStmt production. + EnterWorkflowCallMicroflowStmt(c *WorkflowCallMicroflowStmtContext) + + // EnterWorkflowParameterMapping is called when entering the workflowParameterMapping production. + EnterWorkflowParameterMapping(c *WorkflowParameterMappingContext) + + // EnterWorkflowCallWorkflowStmt is called when entering the workflowCallWorkflowStmt production. + EnterWorkflowCallWorkflowStmt(c *WorkflowCallWorkflowStmtContext) + + // EnterWorkflowDecisionStmt is called when entering the workflowDecisionStmt production. + EnterWorkflowDecisionStmt(c *WorkflowDecisionStmtContext) + + // EnterWorkflowConditionOutcome is called when entering the workflowConditionOutcome production. + EnterWorkflowConditionOutcome(c *WorkflowConditionOutcomeContext) + + // EnterWorkflowParallelSplitStmt is called when entering the workflowParallelSplitStmt production. + EnterWorkflowParallelSplitStmt(c *WorkflowParallelSplitStmtContext) + + // EnterWorkflowParallelPath is called when entering the workflowParallelPath production. + EnterWorkflowParallelPath(c *WorkflowParallelPathContext) + + // EnterWorkflowJumpToStmt is called when entering the workflowJumpToStmt production. + EnterWorkflowJumpToStmt(c *WorkflowJumpToStmtContext) + + // EnterWorkflowWaitForTimerStmt is called when entering the workflowWaitForTimerStmt production. + EnterWorkflowWaitForTimerStmt(c *WorkflowWaitForTimerStmtContext) + + // EnterWorkflowWaitForNotificationStmt is called when entering the workflowWaitForNotificationStmt production. + EnterWorkflowWaitForNotificationStmt(c *WorkflowWaitForNotificationStmtContext) + + // EnterWorkflowAnnotationStmt is called when entering the workflowAnnotationStmt production. + EnterWorkflowAnnotationStmt(c *WorkflowAnnotationStmtContext) + // EnterAlterSettingsClause is called when entering the alterSettingsClause production. EnterAlterSettingsClause(c *AlterSettingsClauseContext) @@ -1129,6 +1186,12 @@ type MDLParserListener interface { // ExitRevokePageAccessStatement is called when exiting the revokePageAccessStatement production. ExitRevokePageAccessStatement(c *RevokePageAccessStatementContext) + // ExitGrantWorkflowAccessStatement is called when exiting the grantWorkflowAccessStatement production. + ExitGrantWorkflowAccessStatement(c *GrantWorkflowAccessStatementContext) + + // ExitRevokeWorkflowAccessStatement is called when exiting the revokeWorkflowAccessStatement production. + ExitRevokeWorkflowAccessStatement(c *RevokeWorkflowAccessStatementContext) + // ExitGrantODataServiceAccessStatement is called when exiting the grantODataServiceAccessStatement production. ExitGrantODataServiceAccessStatement(c *GrantODataServiceAccessStatementContext) @@ -1774,6 +1837,57 @@ type MDLParserListener interface { // ExitBusinessEventAttrDef is called when exiting the businessEventAttrDef production. ExitBusinessEventAttrDef(c *BusinessEventAttrDefContext) + // ExitCreateWorkflowStatement is called when exiting the createWorkflowStatement production. + ExitCreateWorkflowStatement(c *CreateWorkflowStatementContext) + + // ExitWorkflowBody is called when exiting the workflowBody production. + ExitWorkflowBody(c *WorkflowBodyContext) + + // ExitWorkflowActivityStmt is called when exiting the workflowActivityStmt production. + ExitWorkflowActivityStmt(c *WorkflowActivityStmtContext) + + // ExitWorkflowUserTaskStmt is called when exiting the workflowUserTaskStmt production. + ExitWorkflowUserTaskStmt(c *WorkflowUserTaskStmtContext) + + // ExitWorkflowBoundaryEventClause is called when exiting the workflowBoundaryEventClause production. + ExitWorkflowBoundaryEventClause(c *WorkflowBoundaryEventClauseContext) + + // ExitWorkflowUserTaskOutcome is called when exiting the workflowUserTaskOutcome production. + ExitWorkflowUserTaskOutcome(c *WorkflowUserTaskOutcomeContext) + + // ExitWorkflowCallMicroflowStmt is called when exiting the workflowCallMicroflowStmt production. + ExitWorkflowCallMicroflowStmt(c *WorkflowCallMicroflowStmtContext) + + // ExitWorkflowParameterMapping is called when exiting the workflowParameterMapping production. + ExitWorkflowParameterMapping(c *WorkflowParameterMappingContext) + + // ExitWorkflowCallWorkflowStmt is called when exiting the workflowCallWorkflowStmt production. + ExitWorkflowCallWorkflowStmt(c *WorkflowCallWorkflowStmtContext) + + // ExitWorkflowDecisionStmt is called when exiting the workflowDecisionStmt production. + ExitWorkflowDecisionStmt(c *WorkflowDecisionStmtContext) + + // ExitWorkflowConditionOutcome is called when exiting the workflowConditionOutcome production. + ExitWorkflowConditionOutcome(c *WorkflowConditionOutcomeContext) + + // ExitWorkflowParallelSplitStmt is called when exiting the workflowParallelSplitStmt production. + ExitWorkflowParallelSplitStmt(c *WorkflowParallelSplitStmtContext) + + // ExitWorkflowParallelPath is called when exiting the workflowParallelPath production. + ExitWorkflowParallelPath(c *WorkflowParallelPathContext) + + // ExitWorkflowJumpToStmt is called when exiting the workflowJumpToStmt production. + ExitWorkflowJumpToStmt(c *WorkflowJumpToStmtContext) + + // ExitWorkflowWaitForTimerStmt is called when exiting the workflowWaitForTimerStmt production. + ExitWorkflowWaitForTimerStmt(c *WorkflowWaitForTimerStmtContext) + + // ExitWorkflowWaitForNotificationStmt is called when exiting the workflowWaitForNotificationStmt production. + ExitWorkflowWaitForNotificationStmt(c *WorkflowWaitForNotificationStmtContext) + + // ExitWorkflowAnnotationStmt is called when exiting the workflowAnnotationStmt production. + ExitWorkflowAnnotationStmt(c *WorkflowAnnotationStmtContext) + // ExitAlterSettingsClause is called when exiting the alterSettingsClause production. ExitAlterSettingsClause(c *AlterSettingsClauseContext) diff --git a/mdl/visitor/visitor_entity.go b/mdl/visitor/visitor_entity.go index 4df48fd..cf2f1a9 100644 --- a/mdl/visitor/visitor_entity.go +++ b/mdl/visitor/visitor_entity.go @@ -507,12 +507,24 @@ func (b *Builder) ExitAlterEntityAction(ctx *parser.AlterEntityActionContext) { // MODIFY ATTRIBUTE / MODIFY COLUMN if ctx.MODIFY() != nil && (ctx.ATTRIBUTE() != nil || ctx.COLUMN() != nil) && len(attrNames) >= 1 { dt := buildDataType(ctx.DataType()) - b.statements = append(b.statements, &ast.AlterEntityStmt{ + stmt := &ast.AlterEntityStmt{ Name: name, Operation: ast.AlterEntityModifyAttribute, AttributeName: attributeNameText(attrNames[0]), DataType: dt, - }) + } + // Capture CALCULATED constraint if present + for _, constraintCtx := range ctx.AllAttributeConstraint() { + c := constraintCtx.(*parser.AttributeConstraintContext) + if c.CALCULATED() != nil { + stmt.Calculated = true + if qn := c.QualifiedName(); qn != nil { + calcName := buildQualifiedName(qn) + stmt.CalculatedMicroflow = &calcName + } + } + } + b.statements = append(b.statements, stmt) return } @@ -632,6 +644,10 @@ func (b *Builder) ExitDropStatement(ctx *parser.DropStatementContext) { b.statements = append(b.statements, &ast.DropBusinessEventServiceStmt{ Name: buildQualifiedName(names[0]), }) + } else if ctx.WORKFLOW() != nil { + b.statements = append(b.statements, &ast.DropWorkflowStmt{ + Name: buildQualifiedName(names[0]), + }) } } diff --git a/mdl/visitor/visitor_helpers.go b/mdl/visitor/visitor_helpers.go index 5cc25e0..9ba9af5 100644 --- a/mdl/visitor/visitor_helpers.go +++ b/mdl/visitor/visitor_helpers.go @@ -216,6 +216,13 @@ func buildAttributes(ctx parser.IAttributeDefinitionListContext, b *Builder) []a attr.NotNullError = unquoteString(c.STRING_LITERAL().GetText()) } } + if c.CALCULATED() != nil { + attr.Calculated = true + if qn := c.QualifiedName(); qn != nil { + name := buildQualifiedName(qn) + attr.CalculatedMicroflow = &name + } + } } attrs = append(attrs, attr) @@ -267,6 +274,13 @@ func buildSingleAttribute(a *parser.AttributeDefinitionContext) *ast.Attribute { attr.NotNullError = unquoteString(c.STRING_LITERAL().GetText()) } } + if c.CALCULATED() != nil { + attr.Calculated = true + if qn := c.QualifiedName(); qn != nil { + name := buildQualifiedName(qn) + attr.CalculatedMicroflow = &name + } + } } return attr diff --git a/mdl/visitor/visitor_query.go b/mdl/visitor/visitor_query.go index 1cfbfd2..854f41b 100644 --- a/mdl/visitor/visitor_query.go +++ b/mdl/visitor/visitor_query.go @@ -262,6 +262,11 @@ func (b *Builder) ExitShowStatement(ctx *parser.ShowStatementContext) { ObjectType: ast.ShowAccessOnPage, Name: &name, }) + } else if ctx.WORKFLOW() != nil { + b.statements = append(b.statements, &ast.ShowStmt{ + ObjectType: ast.ShowAccessOnWorkflow, + Name: &name, + }) } else { b.statements = append(b.statements, &ast.ShowStmt{ ObjectType: ast.ShowAccessOn, diff --git a/mdl/visitor/visitor_security.go b/mdl/visitor/visitor_security.go index aff99fa..5efc458 100644 --- a/mdl/visitor/visitor_security.go +++ b/mdl/visitor/visitor_security.go @@ -219,6 +219,46 @@ func (b *Builder) ExitRevokePageAccessStatement(ctx *parser.RevokePageAccessStat b.statements = append(b.statements, stmt) } +// ExitGrantWorkflowAccessStatement handles GRANT EXECUTE ON WORKFLOW Module.WF TO role1, role2 +func (b *Builder) ExitGrantWorkflowAccessStatement(ctx *parser.GrantWorkflowAccessStatementContext) { + qn := ctx.QualifiedName() + if qn == nil { + return + } + + stmt := &ast.GrantWorkflowAccessStmt{ + Workflow: buildQualifiedName(qn), + } + + if mrl := ctx.ModuleRoleList(); mrl != nil { + for _, rqn := range mrl.AllQualifiedName() { + stmt.Roles = append(stmt.Roles, buildQualifiedName(rqn)) + } + } + + b.statements = append(b.statements, stmt) +} + +// ExitRevokeWorkflowAccessStatement handles REVOKE EXECUTE ON WORKFLOW Module.WF FROM role1, role2 +func (b *Builder) ExitRevokeWorkflowAccessStatement(ctx *parser.RevokeWorkflowAccessStatementContext) { + qn := ctx.QualifiedName() + if qn == nil { + return + } + + stmt := &ast.RevokeWorkflowAccessStmt{ + Workflow: buildQualifiedName(qn), + } + + if mrl := ctx.ModuleRoleList(); mrl != nil { + for _, rqn := range mrl.AllQualifiedName() { + stmt.Roles = append(stmt.Roles, buildQualifiedName(rqn)) + } + } + + b.statements = append(b.statements, stmt) +} + // ExitGrantODataServiceAccessStatement handles GRANT ACCESS ON ODATA SERVICE Module.Svc TO role1, role2 func (b *Builder) ExitGrantODataServiceAccessStatement(ctx *parser.GrantODataServiceAccessStatementContext) { qn := ctx.QualifiedName() @@ -279,7 +319,7 @@ func (b *Builder) ExitAlterProjectSecurityStatement(ctx *parser.AlterProjectSecu b.statements = append(b.statements, stmt) } -// ExitCreateDemoUserStatement handles CREATE DEMO USER 'name' PASSWORD 'pw' (Role1, Role2) +// ExitCreateDemoUserStatement handles CREATE DEMO USER 'name' PASSWORD 'pw' [ENTITY Module.Entity] (Role1, Role2) func (b *Builder) ExitCreateDemoUserStatement(ctx *parser.CreateDemoUserStatementContext) { sls := ctx.AllSTRING_LITERAL() if len(sls) < 2 { @@ -291,6 +331,11 @@ func (b *Builder) ExitCreateDemoUserStatement(ctx *parser.CreateDemoUserStatemen Password: unquoteString(sls[1].GetText()), } + // Parse optional ENTITY clause + if qn := ctx.QualifiedName(); qn != nil { + stmt.Entity = buildQualifiedName(qn).String() + } + // Parse user role names from identifierOrKeyword list for _, iok := range ctx.AllIdentifierOrKeyword() { stmt.UserRoles = append(stmt.UserRoles, identifierOrKeywordText(iok)) diff --git a/mdl/visitor/visitor_test.go b/mdl/visitor/visitor_test.go index 214ca1e..d154f0e 100644 --- a/mdl/visitor/visitor_test.go +++ b/mdl/visitor/visitor_test.go @@ -1266,3 +1266,219 @@ func TestSQLGenerateConnector(t *testing.T) { }) } } + +func TestCreateDemoUserWithEntity(t *testing.T) { + tests := []struct { + name string + input string + expectedEntity string + expectedUser string + expectedRoles []string + }{ + { + name: "with explicit entity", + input: `CREATE DEMO USER 'admin' PASSWORD '1' ENTITY Administration.Account (Administrator);`, + expectedEntity: "Administration.Account", + expectedUser: "admin", + expectedRoles: []string{"Administrator"}, + }, + { + name: "without entity clause", + input: `CREATE DEMO USER 'admin' PASSWORD '1' (Administrator);`, + expectedEntity: "", + expectedUser: "admin", + expectedRoles: []string{"Administrator"}, + }, + { + name: "with entity and multiple roles", + input: `CREATE DEMO USER 'test' PASSWORD 'pwd' ENTITY MyModule.AppUser (User, Admin);`, + expectedEntity: "MyModule.AppUser", + expectedUser: "test", + expectedRoles: []string{"User", "Admin"}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + prog, errs := Build(tt.input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + return + } + + if len(prog.Statements) != 1 { + t.Fatalf("Expected 1 statement, got %d", len(prog.Statements)) + } + + stmt, ok := prog.Statements[0].(*ast.CreateDemoUserStmt) + if !ok { + t.Fatalf("Expected CreateDemoUserStmt, got %T", prog.Statements[0]) + } + + if stmt.UserName != tt.expectedUser { + t.Errorf("UserName = %q, want %q", stmt.UserName, tt.expectedUser) + } + if stmt.Entity != tt.expectedEntity { + t.Errorf("Entity = %q, want %q", stmt.Entity, tt.expectedEntity) + } + if len(stmt.UserRoles) != len(tt.expectedRoles) { + t.Fatalf("UserRoles count = %d, want %d", len(stmt.UserRoles), len(tt.expectedRoles)) + } + for i, role := range stmt.UserRoles { + if role != tt.expectedRoles[i] { + t.Errorf("UserRoles[%d] = %q, want %q", i, role, tt.expectedRoles[i]) + } + } + }) + } +} + +func TestCalculatedAttributeParsing(t *testing.T) { + input := `CREATE PERSISTENT ENTITY DmTest.Product ( + Name: String(200) NOT NULL, + Price: Decimal, + FullPrice: Decimal CALCULATED + );` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + return + } + + if len(prog.Statements) != 1 { + t.Fatalf("Expected 1 statement, got %d", len(prog.Statements)) + } + + stmt := prog.Statements[0].(*ast.CreateEntityStmt) + if len(stmt.Attributes) != 3 { + t.Fatalf("Expected 3 attributes, got %d", len(stmt.Attributes)) + } + + // Name should NOT be calculated + if stmt.Attributes[0].Calculated { + t.Error("Name attribute should not be calculated") + } + + // Price should NOT be calculated + if stmt.Attributes[1].Calculated { + t.Error("Price attribute should not be calculated") + } + + // FullPrice should be calculated + if !stmt.Attributes[2].Calculated { + t.Error("FullPrice attribute should be calculated") + } + // FullPrice should NOT have a microflow reference (bare CALCULATED) + if stmt.Attributes[2].CalculatedMicroflow != nil { + t.Error("FullPrice attribute should not have a microflow reference with bare CALCULATED") + } +} + +func TestCalculatedAttributeWithMicroflow(t *testing.T) { + input := `CREATE PERSISTENT ENTITY DmTest.Product ( + Name: String(200) NOT NULL, + FullPrice: Decimal CALCULATED DmTest.CalcFullPrice + );` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + return + } + + if len(prog.Statements) != 1 { + t.Fatalf("Expected 1 statement, got %d", len(prog.Statements)) + } + + stmt := prog.Statements[0].(*ast.CreateEntityStmt) + if len(stmt.Attributes) != 2 { + t.Fatalf("Expected 2 attributes, got %d", len(stmt.Attributes)) + } + + // FullPrice should be calculated with microflow reference + fullPrice := stmt.Attributes[1] + if !fullPrice.Calculated { + t.Error("FullPrice attribute should be calculated") + } + if fullPrice.CalculatedMicroflow == nil { + t.Fatal("FullPrice attribute should have a microflow reference") + } + if fullPrice.CalculatedMicroflow.Module != "DmTest" { + t.Errorf("Expected microflow module 'DmTest', got '%s'", fullPrice.CalculatedMicroflow.Module) + } + if fullPrice.CalculatedMicroflow.Name != "CalcFullPrice" { + t.Errorf("Expected microflow name 'CalcFullPrice', got '%s'", fullPrice.CalculatedMicroflow.Name) + } +} + +func TestCalculatedAttributeWithByKeyword(t *testing.T) { + input := `CREATE PERSISTENT ENTITY DmTest.Product ( + Name: String(200) NOT NULL, + FullPrice: Decimal CALCULATED BY DmTest.CalcFullPrice + );` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + return + } + + if len(prog.Statements) != 1 { + t.Fatalf("Expected 1 statement, got %d", len(prog.Statements)) + } + + stmt := prog.Statements[0].(*ast.CreateEntityStmt) + if len(stmt.Attributes) != 2 { + t.Fatalf("Expected 2 attributes, got %d", len(stmt.Attributes)) + } + + fullPrice := stmt.Attributes[1] + if !fullPrice.Calculated { + t.Error("FullPrice attribute should be calculated") + } + if fullPrice.CalculatedMicroflow == nil { + t.Fatal("FullPrice attribute should have a microflow reference") + } + if fullPrice.CalculatedMicroflow.Module != "DmTest" { + t.Errorf("Expected microflow module 'DmTest', got '%s'", fullPrice.CalculatedMicroflow.Module) + } + if fullPrice.CalculatedMicroflow.Name != "CalcFullPrice" { + t.Errorf("Expected microflow name 'CalcFullPrice', got '%s'", fullPrice.CalculatedMicroflow.Name) + } +} + +func TestCalculatedAttributeOnNonPersistentEntity(t *testing.T) { + // This should parse successfully - validation happens at executor level + input := `CREATE NON-PERSISTENT ENTITY DmTest.TempCalc ( + Value: Decimal CALCULATED BY DmTest.CalcValue + );` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + return + } + + if len(prog.Statements) != 1 { + t.Fatalf("Expected 1 statement, got %d", len(prog.Statements)) + } + + stmt := prog.Statements[0].(*ast.CreateEntityStmt) + if stmt.Kind != ast.EntityNonPersistent { + t.Error("Expected non-persistent entity") + } + if !stmt.Attributes[0].Calculated { + t.Error("Value attribute should be calculated") + } +} diff --git a/mdl/visitor/visitor_workflow.go b/mdl/visitor/visitor_workflow.go new file mode 100644 index 0000000..f851de6 --- /dev/null +++ b/mdl/visitor/visitor_workflow.go @@ -0,0 +1,462 @@ +// SPDX-License-Identifier: Apache-2.0 + +package visitor + +import ( + "github.com/mendixlabs/mxcli/mdl/ast" + "github.com/mendixlabs/mxcli/mdl/grammar/parser" +) + +// ExitCreateWorkflowStatement handles CREATE WORKFLOW statements. +func (b *Builder) ExitCreateWorkflowStatement(ctx *parser.CreateWorkflowStatementContext) { + names := ctx.AllQualifiedName() + if len(names) == 0 { + return + } + + stmt := &ast.CreateWorkflowStmt{ + Name: buildQualifiedName(names[0]), + } + + // Parse PARAMETER $Var: Entity + if ctx.PARAMETER() != nil && ctx.VARIABLE() != nil { + stmt.ParameterVar = ctx.VARIABLE().GetText() + // The parameter entity is the second qualified name + if len(names) > 1 { + stmt.ParameterEntity = buildQualifiedName(names[1]) + } + } + + // Parse DISPLAY, DESCRIPTION, EXPORT LEVEL, DUE DATE using positional STRING_LITERAL indexing + allStrings := ctx.AllSTRING_LITERAL() + stringIdx := 0 + + // DISPLAY 'text' + if ctx.DISPLAY() != nil && stringIdx < len(allStrings) { + stmt.DisplayName = unquoteString(allStrings[stringIdx].GetText()) + stringIdx++ + } + + // DESCRIPTION 'text' + if ctx.DESCRIPTION() != nil && stringIdx < len(allStrings) { + stmt.Description = unquoteString(allStrings[stringIdx].GetText()) + stringIdx++ + } + + // EXPORT LEVEL (Identifier | API) + if ctx.EXPORT() != nil && ctx.LEVEL() != nil { + if ctx.IDENTIFIER() != nil { + stmt.ExportLevel = ctx.IDENTIFIER().GetText() + } else if ctx.API() != nil { + stmt.ExportLevel = "API" + } + } + + // Parse OVERVIEW PAGE QualifiedName + overviewPageIdx := -1 + if ctx.OVERVIEW() != nil && ctx.PAGE() != nil { + // Find the overview page qualified name + // It's either names[1] or names[2] depending on whether PARAMETER was present + startIdx := 1 + if ctx.PARAMETER() != nil { + startIdx = 2 + } + if len(names) > startIdx { + stmt.OverviewPage = buildQualifiedName(names[startIdx]) + overviewPageIdx = startIdx + } + } + _ = overviewPageIdx + + // Parse DUE DATE 'expression' + if ctx.DUE() != nil && stringIdx < len(allStrings) { + stmt.DueDate = unquoteString(allStrings[stringIdx].GetText()) + stringIdx++ + } + _ = stringIdx + + // Parse CREATE OR MODIFY + createStmt := findParentCreateStatement(ctx) + if createStmt != nil { + if createStmt.OR() != nil && (createStmt.MODIFY() != nil || createStmt.REPLACE() != nil) { + stmt.CreateOrModify = true + } + } + stmt.Documentation = findDocCommentText(ctx) + + // Parse body + if body := ctx.WorkflowBody(); body != nil { + stmt.Activities = buildWorkflowBody(body) + } + + b.statements = append(b.statements, stmt) +} + +// buildWorkflowBody converts a workflow body context to activity nodes. +func buildWorkflowBody(ctx parser.IWorkflowBodyContext) []ast.WorkflowActivityNode { + if ctx == nil { + return nil + } + bodyCtx := ctx.(*parser.WorkflowBodyContext) + var activities []ast.WorkflowActivityNode + + for _, actCtx := range bodyCtx.AllWorkflowActivityStmt() { + act := buildWorkflowActivityStmt(actCtx) + if act != nil { + activities = append(activities, act) + } + } + + return activities +} + +// buildWorkflowActivityStmt dispatches to the appropriate builder. +func buildWorkflowActivityStmt(ctx parser.IWorkflowActivityStmtContext) ast.WorkflowActivityNode { + if ctx == nil { + return nil + } + actCtx := ctx.(*parser.WorkflowActivityStmtContext) + + if ut := actCtx.WorkflowUserTaskStmt(); ut != nil { + return buildWorkflowUserTask(ut) + } + if cm := actCtx.WorkflowCallMicroflowStmt(); cm != nil { + return buildWorkflowCallMicroflow(cm) + } + if cw := actCtx.WorkflowCallWorkflowStmt(); cw != nil { + return buildWorkflowCallWorkflow(cw) + } + if d := actCtx.WorkflowDecisionStmt(); d != nil { + return buildWorkflowDecision(d) + } + if ps := actCtx.WorkflowParallelSplitStmt(); ps != nil { + return buildWorkflowParallelSplit(ps) + } + if jt := actCtx.WorkflowJumpToStmt(); jt != nil { + return buildWorkflowJumpTo(jt) + } + if wt := actCtx.WorkflowWaitForTimerStmt(); wt != nil { + return buildWorkflowWaitForTimer(wt) + } + if wn := actCtx.WorkflowWaitForNotificationStmt(); wn != nil { + return buildWorkflowWaitForNotification(wn) + } + if ann := actCtx.WorkflowAnnotationStmt(); ann != nil { + return buildWorkflowAnnotation(ann) + } + return nil +} + +// buildWorkflowUserTask builds a WorkflowUserTaskNode from the grammar context. +func buildWorkflowUserTask(ctx parser.IWorkflowUserTaskStmtContext) *ast.WorkflowUserTaskNode { + utCtx := ctx.(*parser.WorkflowUserTaskStmtContext) + + node := &ast.WorkflowUserTaskNode{ + Name: utCtx.IDENTIFIER().GetText(), + IsMultiUser: utCtx.MULTI() != nil, + } + + // Caption is the first STRING_LITERAL + allStrings := utCtx.AllSTRING_LITERAL() + if len(allStrings) > 0 { + node.Caption = unquoteString(allStrings[0].GetText()) + } + + // Qualified names: PAGE, TARGETING MICROFLOW, ENTITY (in order) + names := utCtx.AllQualifiedName() + nameIdx := 0 + + if utCtx.PAGE() != nil && nameIdx < len(names) { + node.Page = buildQualifiedName(names[nameIdx]) + nameIdx++ + } + + if utCtx.MICROFLOW() != nil && nameIdx < len(names) { + node.Targeting.Kind = "microflow" + node.Targeting.Microflow = buildQualifiedName(names[nameIdx]) + nameIdx++ + } + + stringIdx := 1 // allStrings[0] is the caption + if utCtx.XPATH() != nil && stringIdx < len(allStrings) { + node.Targeting.Kind = "xpath" + node.Targeting.XPath = unquoteString(allStrings[stringIdx].GetText()) + stringIdx++ + } + + if utCtx.ENTITY() != nil && nameIdx < len(names) { + node.Entity = buildQualifiedName(names[nameIdx]) + } + + if utCtx.DUE() != nil && utCtx.DATE_TYPE() != nil && stringIdx < len(allStrings) { + node.DueDate = unquoteString(allStrings[stringIdx].GetText()) + stringIdx++ + } + + if utCtx.DESCRIPTION() != nil && stringIdx < len(allStrings) { + node.TaskDescription = unquoteString(allStrings[stringIdx].GetText()) + stringIdx++ + } + + // Outcomes + for _, outcomeCtx := range utCtx.AllWorkflowUserTaskOutcome() { + outcome := buildWorkflowUserTaskOutcome(outcomeCtx) + node.Outcomes = append(node.Outcomes, outcome) + } + + // BoundaryEvents (Issue #7) + for _, beCtx := range utCtx.AllWorkflowBoundaryEventClause() { + node.BoundaryEvents = append(node.BoundaryEvents, buildBoundaryEventNode(beCtx)) + } + + return node +} + +// buildWorkflowUserTaskOutcome builds a WorkflowUserTaskOutcomeNode. +func buildWorkflowUserTaskOutcome(ctx parser.IWorkflowUserTaskOutcomeContext) ast.WorkflowUserTaskOutcomeNode { + outCtx := ctx.(*parser.WorkflowUserTaskOutcomeContext) + outcome := ast.WorkflowUserTaskOutcomeNode{ + Caption: unquoteString(outCtx.STRING_LITERAL().GetText()), + } + if body := outCtx.WorkflowBody(); body != nil { + outcome.Activities = buildWorkflowBody(body) + } + return outcome +} + +// buildWorkflowCallMicroflow builds a WorkflowCallMicroflowNode. +func buildWorkflowCallMicroflow(ctx parser.IWorkflowCallMicroflowStmtContext) *ast.WorkflowCallMicroflowNode { + cmCtx := ctx.(*parser.WorkflowCallMicroflowStmtContext) + node := &ast.WorkflowCallMicroflowNode{ + Microflow: buildQualifiedName(cmCtx.QualifiedName()), + } + + if cmCtx.COMMENT() != nil && cmCtx.STRING_LITERAL() != nil { + node.Caption = unquoteString(cmCtx.STRING_LITERAL().GetText()) + } + + for _, outcomeCtx := range cmCtx.AllWorkflowConditionOutcome() { + outcome := buildWorkflowConditionOutcome(outcomeCtx) + node.Outcomes = append(node.Outcomes, outcome) + } + + // Parameter mappings (Issue #10) + for _, pmCtx := range cmCtx.AllWorkflowParameterMapping() { + pmCtx2 := pmCtx.(*parser.WorkflowParameterMappingContext) + mapping := ast.WorkflowParameterMappingNode{ + Parameter: pmCtx2.QualifiedName().GetText(), + Expression: unquoteString(pmCtx2.STRING_LITERAL().GetText()), + } + node.ParameterMappings = append(node.ParameterMappings, mapping) + } + + // BoundaryEvents (Issue #7) + for _, beCtx := range cmCtx.AllWorkflowBoundaryEventClause() { + node.BoundaryEvents = append(node.BoundaryEvents, buildBoundaryEventNode(beCtx)) + } + + return node +} + +// buildWorkflowCallWorkflow builds a WorkflowCallWorkflowNode. +func buildWorkflowCallWorkflow(ctx parser.IWorkflowCallWorkflowStmtContext) *ast.WorkflowCallWorkflowNode { + cwCtx := ctx.(*parser.WorkflowCallWorkflowStmtContext) + node := &ast.WorkflowCallWorkflowNode{ + Workflow: buildQualifiedName(cwCtx.QualifiedName()), + } + + if cwCtx.COMMENT() != nil && cwCtx.STRING_LITERAL() != nil { + node.Caption = unquoteString(cwCtx.STRING_LITERAL().GetText()) + } + + // Parameter mappings + for _, pmCtx := range cwCtx.AllWorkflowParameterMapping() { + pmCtx2 := pmCtx.(*parser.WorkflowParameterMappingContext) + mapping := ast.WorkflowParameterMappingNode{ + Parameter: pmCtx2.QualifiedName().GetText(), + Expression: unquoteString(pmCtx2.STRING_LITERAL().GetText()), + } + node.ParameterMappings = append(node.ParameterMappings, mapping) + } + + return node +} + +// buildWorkflowDecision builds a WorkflowDecisionNode. +func buildWorkflowDecision(ctx parser.IWorkflowDecisionStmtContext) *ast.WorkflowDecisionNode { + dCtx := ctx.(*parser.WorkflowDecisionStmtContext) + node := &ast.WorkflowDecisionNode{} + + allStrings := dCtx.AllSTRING_LITERAL() + stringIdx := 0 + + // First STRING_LITERAL is the expression (if present and COMMENT is not present or expression comes first) + if len(allStrings) > 0 && dCtx.COMMENT() == nil { + // All strings are expression + node.Expression = unquoteString(allStrings[0].GetText()) + stringIdx = 1 + } else if len(allStrings) > 0 && dCtx.COMMENT() != nil { + // Distinguish expression from comment + if len(allStrings) >= 2 { + node.Expression = unquoteString(allStrings[0].GetText()) + node.Caption = unquoteString(allStrings[1].GetText()) + } else { + // Only one string with COMMENT - it's the caption + node.Caption = unquoteString(allStrings[0].GetText()) + } + stringIdx = len(allStrings) + } + _ = stringIdx + + for _, outcomeCtx := range dCtx.AllWorkflowConditionOutcome() { + outcome := buildWorkflowConditionOutcome(outcomeCtx) + node.Outcomes = append(node.Outcomes, outcome) + } + + return node +} + +// buildWorkflowConditionOutcome builds a WorkflowConditionOutcomeNode. +func buildWorkflowConditionOutcome(ctx parser.IWorkflowConditionOutcomeContext) ast.WorkflowConditionOutcomeNode { + coCtx := ctx.(*parser.WorkflowConditionOutcomeContext) + outcome := ast.WorkflowConditionOutcomeNode{} + + if coCtx.TRUE() != nil { + outcome.Value = "True" + } else if coCtx.FALSE() != nil { + outcome.Value = "False" + } else if coCtx.DEFAULT() != nil { + outcome.Value = "Default" + } else if coCtx.STRING_LITERAL() != nil { + outcome.Value = unquoteString(coCtx.STRING_LITERAL().GetText()) + } + + if body := coCtx.WorkflowBody(); body != nil { + outcome.Activities = buildWorkflowBody(body) + } + + return outcome +} + +// buildWorkflowParallelSplit builds a WorkflowParallelSplitNode. +func buildWorkflowParallelSplit(ctx parser.IWorkflowParallelSplitStmtContext) *ast.WorkflowParallelSplitNode { + psCtx := ctx.(*parser.WorkflowParallelSplitStmtContext) + node := &ast.WorkflowParallelSplitNode{} + + if psCtx.COMMENT() != nil && psCtx.STRING_LITERAL() != nil { + node.Caption = unquoteString(psCtx.STRING_LITERAL().GetText()) + } + + for _, pathCtx := range psCtx.AllWorkflowParallelPath() { + path := buildWorkflowParallelPath(pathCtx) + node.Paths = append(node.Paths, path) + } + + return node +} + +// buildWorkflowParallelPath builds a WorkflowParallelPathNode. +func buildWorkflowParallelPath(ctx parser.IWorkflowParallelPathContext) ast.WorkflowParallelPathNode { + ppCtx := ctx.(*parser.WorkflowParallelPathContext) + path := ast.WorkflowParallelPathNode{} + + if ppCtx.NUMBER_LITERAL() != nil { + path.PathNumber = parseInt(ppCtx.NUMBER_LITERAL().GetText()) + } + + if body := ppCtx.WorkflowBody(); body != nil { + path.Activities = buildWorkflowBody(body) + } + + return path +} + +// buildWorkflowJumpTo builds a WorkflowJumpToNode. +func buildWorkflowJumpTo(ctx parser.IWorkflowJumpToStmtContext) *ast.WorkflowJumpToNode { + jtCtx := ctx.(*parser.WorkflowJumpToStmtContext) + node := &ast.WorkflowJumpToNode{ + Target: jtCtx.IDENTIFIER().GetText(), + } + + if jtCtx.COMMENT() != nil && jtCtx.STRING_LITERAL() != nil { + node.Caption = unquoteString(jtCtx.STRING_LITERAL().GetText()) + } + + return node +} + +// buildWorkflowWaitForTimer builds a WorkflowWaitForTimerNode. +func buildWorkflowWaitForTimer(ctx parser.IWorkflowWaitForTimerStmtContext) *ast.WorkflowWaitForTimerNode { + wtCtx := ctx.(*parser.WorkflowWaitForTimerStmtContext) + node := &ast.WorkflowWaitForTimerNode{} + + allStrings := wtCtx.AllSTRING_LITERAL() + if len(allStrings) > 0 && wtCtx.COMMENT() == nil { + node.DelayExpression = unquoteString(allStrings[0].GetText()) + } else if len(allStrings) >= 2 && wtCtx.COMMENT() != nil { + node.DelayExpression = unquoteString(allStrings[0].GetText()) + node.Caption = unquoteString(allStrings[1].GetText()) + } else if len(allStrings) == 1 && wtCtx.COMMENT() != nil { + node.Caption = unquoteString(allStrings[0].GetText()) + } + + return node +} + +// buildWorkflowWaitForNotification builds a WorkflowWaitForNotificationNode. +func buildWorkflowWaitForNotification(ctx parser.IWorkflowWaitForNotificationStmtContext) *ast.WorkflowWaitForNotificationNode { + wnCtx := ctx.(*parser.WorkflowWaitForNotificationStmtContext) + node := &ast.WorkflowWaitForNotificationNode{} + + if wnCtx.COMMENT() != nil && wnCtx.STRING_LITERAL() != nil { + node.Caption = unquoteString(wnCtx.STRING_LITERAL().GetText()) + } + + // BoundaryEvents (Issue #7) + for _, beCtx := range wnCtx.AllWorkflowBoundaryEventClause() { + node.BoundaryEvents = append(node.BoundaryEvents, buildBoundaryEventNode(beCtx)) + } + + return node +} + +// buildBoundaryEventNode builds a WorkflowBoundaryEventNode from a grammar context. +func buildBoundaryEventNode(beCtx parser.IWorkflowBoundaryEventClauseContext) ast.WorkflowBoundaryEventNode { + beCtx2 := beCtx.(*parser.WorkflowBoundaryEventClauseContext) + be := ast.WorkflowBoundaryEventNode{} + if beCtx2.NON() != nil { + be.EventType = "NonInterruptingTimer" + } else if beCtx2.INTERRUPTING() != nil { + be.EventType = "InterruptingTimer" + } else { + be.EventType = "Timer" + } + if beCtx2.STRING_LITERAL() != nil { + be.Delay = unquoteString(beCtx2.STRING_LITERAL().GetText()) + } + if body := beCtx2.WorkflowBody(); body != nil { + be.Activities = buildWorkflowBody(body) + } + return be +} + +// buildWorkflowAnnotation builds a WorkflowAnnotationActivityNode from the grammar context. +func buildWorkflowAnnotation(ctx parser.IWorkflowAnnotationStmtContext) *ast.WorkflowAnnotationActivityNode { + annCtx := ctx.(*parser.WorkflowAnnotationStmtContext) + node := &ast.WorkflowAnnotationActivityNode{} + if annCtx.STRING_LITERAL() != nil { + node.Text = unquoteString(annCtx.STRING_LITERAL().GetText()) + } + return node +} + +// parseInt parses a string as an integer, returning 0 on failure. +func parseInt(s string) int { + n := 0 + for _, c := range s { + if c >= '0' && c <= '9' { + n = n*10 + int(c-'0') + } + } + return n +} diff --git a/mdl/visitor/visitor_workflow_test.go b/mdl/visitor/visitor_workflow_test.go new file mode 100644 index 0000000..ef6d53a --- /dev/null +++ b/mdl/visitor/visitor_workflow_test.go @@ -0,0 +1,577 @@ +// SPDX-License-Identifier: Apache-2.0 + +package visitor + +import ( + "testing" + + "github.com/mendixlabs/mxcli/mdl/ast" +) + +func TestWorkflowVisitor_BoundaryEventInterrupting(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + USER TASK act1 'Caption' + OUTCOMES 'Done' { } + BOUNDARY EVENT INTERRUPTING TIMER '${PT1H}'; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + if len(prog.Statements) != 1 { + t.Fatalf("Expected 1 statement, got %d", len(prog.Statements)) + } + + stmt, ok := prog.Statements[0].(*ast.CreateWorkflowStmt) + if !ok { + t.Fatalf("Expected CreateWorkflowStmt, got %T", prog.Statements[0]) + } + + if len(stmt.Activities) == 0 { + t.Fatal("Expected at least 1 activity") + } + + userTask, ok := stmt.Activities[0].(*ast.WorkflowUserTaskNode) + if !ok { + t.Fatalf("Expected WorkflowUserTaskNode, got %T", stmt.Activities[0]) + } + + if len(userTask.BoundaryEvents) == 0 { + t.Fatal("Expected at least 1 boundary event") + } + + be := userTask.BoundaryEvents[0] + if be.EventType != "InterruptingTimer" { + t.Errorf("Expected EventType 'InterruptingTimer', got %q", be.EventType) + } + if be.Delay != "${PT1H}" { + t.Errorf("Expected Delay '${PT1H}', got %q", be.Delay) + } +} + +func TestWorkflowVisitor_BoundaryEventNonInterrupting(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + USER TASK act1 'Caption' + OUTCOMES 'Done' { } + BOUNDARY EVENT NON INTERRUPTING TIMER '${PT2H}'; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + userTask := stmt.Activities[0].(*ast.WorkflowUserTaskNode) + + if len(userTask.BoundaryEvents) == 0 { + t.Fatal("Expected at least 1 boundary event") + } + + be := userTask.BoundaryEvents[0] + if be.EventType != "NonInterruptingTimer" { + t.Errorf("Expected EventType 'NonInterruptingTimer', got %q", be.EventType) + } + if be.Delay != "${PT2H}" { + t.Errorf("Expected Delay '${PT2H}', got %q", be.Delay) + } +} + +func TestWorkflowVisitor_BoundaryEventTimerBare(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + USER TASK act1 'Caption' + OUTCOMES 'Done' { } + BOUNDARY EVENT TIMER; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + userTask := stmt.Activities[0].(*ast.WorkflowUserTaskNode) + + if len(userTask.BoundaryEvents) == 0 { + t.Fatal("Expected at least 1 boundary event") + } + + be := userTask.BoundaryEvents[0] + if be.EventType != "Timer" { + t.Errorf("Expected EventType 'Timer', got %q", be.EventType) + } + if be.Delay != "" { + t.Errorf("Expected empty Delay, got %q", be.Delay) + } +} + +func TestWorkflowVisitor_AnnotationRoundTrip(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + ANNOTATION 'This is a test note'; + USER TASK act1 'Do something' + OUTCOMES 'Done' { }; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + if len(stmt.Activities) < 2 { + t.Fatalf("Expected at least 2 activities, got %d", len(stmt.Activities)) + } + + ann, ok := stmt.Activities[0].(*ast.WorkflowAnnotationActivityNode) + if !ok { + t.Fatalf("Expected WorkflowAnnotationActivityNode, got %T", stmt.Activities[0]) + } + if ann.Text != "This is a test note" { + t.Errorf("Expected annotation text 'This is a test note', got %q", ann.Text) + } +} + +func TestWorkflowVisitor_BoundaryEventWithSubFlow(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + WAIT FOR NOTIFICATION + BOUNDARY EVENT INTERRUPTING TIMER '${PT1H}' { + CALL MICROFLOW M.HandleTimeout; + }; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + if len(stmt.Activities) == 0 { + t.Fatal("Expected at least 1 activity") + } + + waitNode, ok := stmt.Activities[0].(*ast.WorkflowWaitForNotificationNode) + if !ok { + t.Fatalf("Expected WorkflowWaitForNotificationNode, got %T", stmt.Activities[0]) + } + + if len(waitNode.BoundaryEvents) == 0 { + t.Fatal("Expected at least 1 boundary event") + } + + be := waitNode.BoundaryEvents[0] + if be.EventType != "InterruptingTimer" { + t.Errorf("Expected EventType 'InterruptingTimer', got %q", be.EventType) + } + if be.Delay != "${PT1H}" { + t.Errorf("Expected Delay '${PT1H}', got %q", be.Delay) + } + if len(be.Activities) == 0 { + t.Fatal("Expected sub-flow activities in boundary event") + } + callMf, ok := be.Activities[0].(*ast.WorkflowCallMicroflowNode) + if !ok { + t.Fatalf("Expected WorkflowCallMicroflowNode in sub-flow, got %T", be.Activities[0]) + } + if callMf.Microflow.Name != "HandleTimeout" { + t.Errorf("Expected microflow name 'HandleTimeout', got %q", callMf.Microflow.Name) + } +} + +func TestWorkflowVisitor_MultiUserTask(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + MULTI USER TASK act1 'Caption' + PAGE M.ReviewPage + OUTCOMES 'Approve' { }; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if len(stmt.Activities) == 0 { + t.Fatal("Expected at least 1 activity") + } + + userTask, ok := stmt.Activities[0].(*ast.WorkflowUserTaskNode) + if !ok { + t.Fatalf("Expected WorkflowUserTaskNode, got %T", stmt.Activities[0]) + } + + if !userTask.IsMultiUser { + t.Error("Expected IsMultiUser to be true") + } + if userTask.Page.Module != "M" || userTask.Page.Name != "ReviewPage" { + t.Errorf("Expected Page M.ReviewPage, got %s.%s", userTask.Page.Module, userTask.Page.Name) + } +} + +func TestWorkflowVisitor_ParameterMappingWith(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + CALL MICROFLOW M.CalcDiscount + WITH (Amount = '$WorkflowContext/Amount') + OUTCOMES + TRUE -> { } + FALSE -> { }; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if len(stmt.Activities) == 0 { + t.Fatal("Expected at least 1 activity") + } + + callMf, ok := stmt.Activities[0].(*ast.WorkflowCallMicroflowNode) + if !ok { + t.Fatalf("Expected WorkflowCallMicroflowNode, got %T", stmt.Activities[0]) + } + + if len(callMf.ParameterMappings) == 0 { + t.Fatal("Expected at least 1 parameter mapping") + } + + pm := callMf.ParameterMappings[0] + if pm.Parameter != "Amount" { + t.Errorf("Expected Parameter 'Amount', got %q", pm.Parameter) + } + if pm.Expression != "$WorkflowContext/Amount" { + t.Errorf("Expected Expression '$WorkflowContext/Amount', got %q", pm.Expression) + } +} + +func TestWorkflowVisitor_CallWorkflowWithParams(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + CALL WORKFLOW M.SubWorkflow COMMENT 'Call sub' WITH (WorkflowContext = '$WorkflowContext'); +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if len(stmt.Activities) == 0 { + t.Fatal("Expected at least 1 activity") + } + + callWf, ok := stmt.Activities[0].(*ast.WorkflowCallWorkflowNode) + if !ok { + t.Fatalf("Expected WorkflowCallWorkflowNode, got %T", stmt.Activities[0]) + } + + if callWf.Caption != "Call sub" { + t.Errorf("Expected Caption 'Call sub', got %q", callWf.Caption) + } + + if len(callWf.ParameterMappings) != 1 { + t.Fatalf("Expected 1 parameter mapping, got %d", len(callWf.ParameterMappings)) + } + + pm := callWf.ParameterMappings[0] + if pm.Parameter != "WorkflowContext" { + t.Errorf("Expected Parameter 'WorkflowContext', got %q", pm.Parameter) + } + if pm.Expression != "$WorkflowContext" { + t.Errorf("Expected Expression '$WorkflowContext', got %q", pm.Expression) + } +} + +func TestWorkflowVisitor_UserTaskDueDate(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + USER TASK task1 'My Task' + ENTITY M.TaskContext + DUE DATE 'PT24H' + OUTCOMES 'Done' { }; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + userTask, ok := stmt.Activities[0].(*ast.WorkflowUserTaskNode) + if !ok { + t.Fatalf("Expected WorkflowUserTaskNode, got %T", stmt.Activities[0]) + } + + if userTask.DueDate != "PT24H" { + t.Errorf("Expected DueDate 'PT24H', got %q", userTask.DueDate) + } +} + +func TestWorkflowVisitor_UserTaskDueDateWithXPath(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + USER TASK task1 'My Task' + TARGETING XPATH '[Assignee = $currentUser]' + ENTITY M.TaskContext + DUE DATE 'PT48H' + OUTCOMES 'Done' { }; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + userTask, ok := stmt.Activities[0].(*ast.WorkflowUserTaskNode) + if !ok { + t.Fatalf("Expected WorkflowUserTaskNode, got %T", stmt.Activities[0]) + } + + if userTask.Targeting.Kind != "xpath" { + t.Errorf("Expected Targeting.Kind 'xpath', got %q", userTask.Targeting.Kind) + } + if userTask.DueDate != "PT48H" { + t.Errorf("Expected DueDate 'PT48H', got %q", userTask.DueDate) + } +} + +func TestWorkflowVisitor_Annotation(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + ANNOTATION 'This is a workflow note'; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if len(stmt.Activities) == 0 { + t.Fatal("Expected at least 1 activity") + } + + ann, ok := stmt.Activities[0].(*ast.WorkflowAnnotationActivityNode) + if !ok { + t.Fatalf("Expected WorkflowAnnotationActivityNode, got %T", stmt.Activities[0]) + } + + if ann.Text != "This is a workflow note" { + t.Errorf("Expected Text 'This is a workflow note', got %q", ann.Text) + } +} + +func TestWorkflowVisitor_DisplayDescriptionExportLevel(t *testing.T) { + input := `CREATE WORKFLOW Module.Test + PARAMETER $ctx: Module.Entity + DISPLAY 'My Display Name' + DESCRIPTION 'My description' + EXPORT LEVEL Hidden +BEGIN +END WORKFLOW` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + if len(prog.Statements) != 1 { + t.Fatalf("Expected 1 statement, got %d", len(prog.Statements)) + } + + stmt, ok := prog.Statements[0].(*ast.CreateWorkflowStmt) + if !ok { + t.Fatalf("Expected CreateWorkflowStmt, got %T", prog.Statements[0]) + } + + if stmt.DisplayName != "My Display Name" { + t.Errorf("Expected DisplayName 'My Display Name', got %q", stmt.DisplayName) + } + if stmt.Description != "My description" { + t.Errorf("Expected Description 'My description', got %q", stmt.Description) + } + if stmt.ExportLevel != "Hidden" { + t.Errorf("Expected ExportLevel 'Hidden', got %q", stmt.ExportLevel) + } +} + +func TestWorkflowVisitor_DisplayOnly(t *testing.T) { + input := `CREATE WORKFLOW Module.Test + DISPLAY 'Just a display name' +BEGIN +END WORKFLOW` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if stmt.DisplayName != "Just a display name" { + t.Errorf("Expected DisplayName 'Just a display name', got %q", stmt.DisplayName) + } + if stmt.Description != "" { + t.Errorf("Expected empty Description, got %q", stmt.Description) + } + if stmt.ExportLevel != "" { + t.Errorf("Expected empty ExportLevel, got %q", stmt.ExportLevel) + } +} + +func TestWorkflowVisitor_DescriptionWithoutDisplay(t *testing.T) { + input := `CREATE WORKFLOW Module.Test + DESCRIPTION 'Only description' +BEGIN +END WORKFLOW` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if stmt.DisplayName != "" { + t.Errorf("Expected empty DisplayName, got %q", stmt.DisplayName) + } + if stmt.Description != "Only description" { + t.Errorf("Expected Description 'Only description', got %q", stmt.Description) + } +} + +func TestWorkflowVisitor_ExportLevelAPI(t *testing.T) { + input := `CREATE WORKFLOW Module.Test + EXPORT LEVEL API +BEGIN +END WORKFLOW` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if stmt.ExportLevel != "API" { + t.Errorf("Expected ExportLevel 'API', got %q", stmt.ExportLevel) + } +} + +func TestWorkflowVisitor_AllMetadataWithDueDate(t *testing.T) { + input := `CREATE WORKFLOW Module.Test + PARAMETER $ctx: Module.Entity + DISPLAY 'Approval Workflow' + DESCRIPTION 'Handles the approval process' + EXPORT LEVEL Hidden + DUE DATE 'addDays([%%CurrentDateTime%%], 7)' +BEGIN +END WORKFLOW` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, err := range errs { + t.Errorf("Parse error: %v", err) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + + if stmt.DisplayName != "Approval Workflow" { + t.Errorf("Expected DisplayName 'Approval Workflow', got %q", stmt.DisplayName) + } + if stmt.Description != "Handles the approval process" { + t.Errorf("Expected Description 'Handles the approval process', got %q", stmt.Description) + } + if stmt.ExportLevel != "Hidden" { + t.Errorf("Expected ExportLevel 'Hidden', got %q", stmt.ExportLevel) + } + if stmt.DueDate != "addDays([%%CurrentDateTime%%], 7)" { + t.Errorf("Expected DueDate 'addDays([%%%%CurrentDateTime%%%%], 7)', got %q", stmt.DueDate) + } +} + +func TestWorkflowVisitor_UserTaskDescription(t *testing.T) { + input := `CREATE WORKFLOW M.TestWF +BEGIN + USER TASK review 'Review' + PAGE M.ReviewPage + DESCRIPTION 'Please review carefully' + OUTCOMES 'Done' { }; +END WORKFLOW;` + + prog, errs := Build(input) + if len(errs) > 0 { + for _, e := range errs { + t.Errorf("Parse error: %v", e) + } + t.FailNow() + } + + stmt := prog.Statements[0].(*ast.CreateWorkflowStmt) + userTask := stmt.Activities[0].(*ast.WorkflowUserTaskNode) + + if userTask.TaskDescription != "Please review carefully" { + t.Errorf("TaskDescription = %q, want %q", userTask.TaskDescription, "Please review carefully") + } +} diff --git a/model/types.go b/model/types.go index de60f2b..fd393ba 100644 --- a/model/types.go +++ b/model/types.go @@ -6,6 +6,8 @@ package model import ( "encoding/json" "time" + + "go.mongodb.org/mongo-driver/bson" ) // ID represents a unique identifier for model elements. @@ -728,7 +730,7 @@ type UnknownElement struct { Position Point `json:"position,omitempty"` Name string `json:"name,omitempty"` Caption string `json:"caption,omitempty"` - RawFields map[string]any `json:"-"` + RawDoc bson.D `json:"-"` FieldKinds map[string]string `json:"-"` } @@ -746,3 +748,4 @@ func (u *UnknownElement) GetCaption() string { return u.Caption } // ActivityType returns the type name (satisfies workflows.WorkflowActivity). func (u *UnknownElement) ActivityType() string { return u.TypeName } + diff --git a/sdk/domainmodel/domainmodel.go b/sdk/domainmodel/domainmodel.go index 952a80a..3c5ad7b 100644 --- a/sdk/domainmodel/domainmodel.go +++ b/sdk/domainmodel/domainmodel.go @@ -271,6 +271,7 @@ type AttributeValue struct { Type string `json:"type,omitempty"` DefaultValue string `json:"defaultValue,omitempty"` MicroflowID model.ID `json:"microflowId,omitempty"` + MicroflowName string `json:"microflowName,omitempty"` // Qualified name (e.g. "Module.Microflow") — BSON stores ByNameReference as string ViewReference string `json:"viewReference,omitempty"` // OQL column reference for view entity attributes } diff --git a/sdk/mpr/parser.go b/sdk/mpr/parser.go index 197d075..2c0725e 100644 --- a/sdk/mpr/parser.go +++ b/sdk/mpr/parser.go @@ -157,7 +157,7 @@ type BsonArrayInfo struct { } // extractBsonArrayWithMarker extracts items from a Mendix BSON array, preserving the marker. -// Returns the marker (1, 2, or 3) and the items after the marker. +// Returns the marker (2 or 3) and the items after the marker. func extractBsonArrayWithMarker(v any) BsonArrayInfo { if v == nil { return BsonArrayInfo{} diff --git a/sdk/mpr/parser_domainmodel.go b/sdk/mpr/parser_domainmodel.go index cd66b55..451529a 100644 --- a/sdk/mpr/parser_domainmodel.go +++ b/sdk/mpr/parser_domainmodel.go @@ -236,8 +236,9 @@ func parseAttributeValue(raw map[string]any) *domainmodel.AttributeValue { return val case "DomainModels$CalculatedValue": val := &domainmodel.AttributeValue{ - Type: "CalculatedValue", - MicroflowID: model.ID(extractBsonID(raw["Microflow"])), + Type: "CalculatedValue", + MicroflowID: model.ID(extractBsonID(raw["Microflow"])), + MicroflowName: extractString(raw["Microflow"]), } val.ID = valueID return val diff --git a/sdk/mpr/parser_microflow.go b/sdk/mpr/parser_microflow.go index 40967fd..ecb0d12 100644 --- a/sdk/mpr/parser_microflow.go +++ b/sdk/mpr/parser_microflow.go @@ -11,6 +11,7 @@ import ( "github.com/mendixlabs/mxcli/sdk/microflows" "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" ) func (r *Reader) parseMicroflow(unitID, containerID string, contents []byte) (*microflows.Microflow, error) { @@ -235,6 +236,22 @@ func parseMicroflowObjectCollection(raw map[string]any) *microflows.MicroflowObj // Parse objects array (int32/int64 version markers are skipped by extractBsonMap returning nil) for _, obj := range extractBsonSlice(raw["Objects"]) { + // Prefer primitive.D path to preserve field ordering for unknown types + if rawD, ok := obj.(primitive.D); ok { + typeName, _ := rawD.Map()["$Type"].(string) + if typeName == "" { + continue + } + if fn, ok := microflowObjectParsers[typeName]; ok { + if mfObj := fn(rawD.Map()); mfObj != nil { + collection.Objects = append(collection.Objects, mfObj) + } + } else { + collection.Objects = append(collection.Objects, newUnknownObjectFromD(typeName, bson.D(rawD))) + } + continue + } + // Fallback for map[string]any if objMap := extractBsonMap(obj); objMap != nil { if mfObj := parseMicroflowObject(objMap); mfObj != nil { collection.Objects = append(collection.Objects, mfObj) diff --git a/sdk/mpr/parser_unknown.go b/sdk/mpr/parser_unknown.go index eb80161..1ac32d9 100644 --- a/sdk/mpr/parser_unknown.go +++ b/sdk/mpr/parser_unknown.go @@ -2,7 +2,10 @@ package mpr -import "github.com/mendixlabs/mxcli/model" +import ( + "github.com/mendixlabs/mxcli/model" + "go.mongodb.org/mongo-driver/bson" +) // newUnknownObject creates an UnknownElement that preserves raw BSON fields // for unrecognized $Type values, preventing silent data loss. @@ -13,9 +16,14 @@ func newUnknownObject(typeName string, raw map[string]any) *model.UnknownElement if raw != nil { id = extractBsonID(raw["$ID"]) } + // convert map to bson.D for storage + doc := make(bson.D, 0, len(raw)) + for k, v := range raw { + doc = append(doc, bson.E{Key: k, Value: v}) + } elem := &model.UnknownElement{ BaseElement: model.BaseElement{ID: model.ID(id), TypeName: typeName}, - RawFields: raw, + RawDoc: doc, } if raw != nil { elem.Position = parsePoint(raw["RelativeMiddlePoint"]) @@ -28,3 +36,29 @@ func newUnknownObject(typeName string, raw map[string]any) *model.UnknownElement } return elem } + +// newUnknownObjectFromD creates an UnknownElement from a bson.D document, +// preserving field ordering for round-trip fidelity. +func newUnknownObjectFromD(typeName string, raw bson.D) *model.UnknownElement { + elem := &model.UnknownElement{ + BaseElement: model.BaseElement{TypeName: typeName}, + RawDoc: raw, + } + if len(raw) > 0 { + elem.FieldKinds = make(map[string]string, len(raw)) + for _, e := range raw { + switch e.Key { + case "$ID": + elem.ID = model.ID(extractBsonID(e.Value)) + case "Name": + elem.Name = extractString(e.Value) + case "Caption": + elem.Caption = extractString(e.Value) + case "RelativeMiddlePoint": + elem.Position = parsePoint(e.Value) + } + elem.FieldKinds[e.Key] = inferPropertyKind(e.Key, e.Value) + } + } + return elem +} diff --git a/sdk/mpr/parser_workflow.go b/sdk/mpr/parser_workflow.go index 06d91e8..88c4b85 100644 --- a/sdk/mpr/parser_workflow.go +++ b/sdk/mpr/parser_workflow.go @@ -4,6 +4,7 @@ package mpr import ( "fmt" + "strings" "github.com/mendixlabs/mxcli/model" "github.com/mendixlabs/mxcli/sdk/workflows" @@ -40,6 +41,16 @@ func (r *Reader) parseWorkflow(unitID, containerID string, contents []byte) (*wo w.ExportLevel = exportLevel } + // Parse Annotation + if annotRaw := raw["Annotation"]; annotRaw != nil { + annotMap := toMap(annotRaw) + if annotMap != nil { + if desc, ok := annotMap["Description"].(string); ok { + w.Annotation = desc + } + } + } + // Parse Parameter (PART — DomainModels$IndirectEntityRef or similar) if paramRaw := raw["Parameter"]; paramRaw != nil { w.Parameter = parseWorkflowParameter(toMap(paramRaw)) @@ -66,6 +77,14 @@ func (r *Reader) parseWorkflow(unitID, containerID string, contents []byte) (*wo w.DueDate = dueDate } + // Parse allowed module roles (BY_NAME references) + allowedRoles := extractBsonArray(raw["AllowedModuleRoles"]) + for _, r := range allowedRoles { + if name, ok := r.(string); ok { + w.AllowedModuleRoles = append(w.AllowedModuleRoles, model.ID(name)) + } + } + // Parse Flow (PART — Workflows$Flow) if flowRaw := raw["Flow"]; flowRaw != nil { w.Flow = parseWorkflowFlow(toMap(flowRaw)) @@ -162,25 +181,41 @@ func parseWorkflowFlow(raw map[string]any) *workflows.Flow { } // workflowActivityParsers maps Mendix $Type strings to their workflow activity parser functions. -// Declared as a nil var and populated in init() so that the map literal can -// reference parseParallelSplitActivity, which itself calls parseWorkflowFlow, -// keeping the package-level initialization order unambiguous. +// Initialized in init() to avoid initialization cycle (parseParallelSplitActivity → parseWorkflowFlow → parseWorkflowActivity). var workflowActivityParsers map[string]func(map[string]any) workflows.WorkflowActivity func init() { workflowActivityParsers = map[string]func(map[string]any) workflows.WorkflowActivity{ - "Workflows$EndWorkflowActivity": func(r map[string]any) workflows.WorkflowActivity { return parseEndWorkflowActivity(r) }, - "Workflows$UserTask": func(r map[string]any) workflows.WorkflowActivity { return parseUserTask(r) }, - "Workflows$SingleUserTaskActivity": func(r map[string]any) workflows.WorkflowActivity { return parseUserTask(r) }, - "Workflows$MultiUserTaskActivity": func(r map[string]any) workflows.WorkflowActivity { return parseUserTask(r) }, - "Workflows$CallMicroflowTask": func(r map[string]any) workflows.WorkflowActivity { return parseCallMicroflowTask(r) }, - "Workflows$CallWorkflowActivity": func(r map[string]any) workflows.WorkflowActivity { return parseCallWorkflowActivity(r) }, - "Workflows$ExclusiveSplitActivity": func(r map[string]any) workflows.WorkflowActivity { return parseExclusiveSplitActivity(r) }, - "Workflows$ParallelSplitActivity": func(r map[string]any) workflows.WorkflowActivity { return parseParallelSplitActivity(r) }, - "Workflows$JumpToActivity": func(r map[string]any) workflows.WorkflowActivity { return parseJumpToActivity(r) }, - "Workflows$WaitForTimerActivity": func(r map[string]any) workflows.WorkflowActivity { return parseWaitForTimerActivity(r) }, - "Workflows$WaitForNotificationActivity": func(r map[string]any) workflows.WorkflowActivity { return parseWaitForNotificationActivity(r) }, - "Workflows$StartWorkflowActivity": func(r map[string]any) workflows.WorkflowActivity { return parseEndWorkflowActivity(r) }, + "Workflows$EndWorkflowActivity": func(r map[string]any) workflows.WorkflowActivity { return parseEndWorkflowActivity(r) }, + "Workflows$UserTask": func(r map[string]any) workflows.WorkflowActivity { return parseUserTask(r) }, + "Workflows$SingleUserTaskActivity": func(r map[string]any) workflows.WorkflowActivity { return parseUserTask(r) }, + "Workflows$MultiUserTaskActivity": func(r map[string]any) workflows.WorkflowActivity { return parseMultiUserTask(r) }, + "Workflows$CallMicroflowTask": func(r map[string]any) workflows.WorkflowActivity { return parseCallMicroflowTask(r) }, + "Workflows$CallWorkflowActivity": func(r map[string]any) workflows.WorkflowActivity { return parseCallWorkflowActivity(r) }, + "Workflows$ExclusiveSplitActivity": func(r map[string]any) workflows.WorkflowActivity { return parseExclusiveSplitActivity(r) }, + "Workflows$ParallelSplitActivity": func(r map[string]any) workflows.WorkflowActivity { return parseParallelSplitActivity(r) }, + "Workflows$JumpToActivity": func(r map[string]any) workflows.WorkflowActivity { return parseJumpToActivity(r) }, + "Workflows$WaitForTimerActivity": func(r map[string]any) workflows.WorkflowActivity { return parseWaitForTimerActivity(r) }, + "Workflows$WaitForNotificationActivity": func(r map[string]any) workflows.WorkflowActivity { return parseWaitForNotificationActivity(r) }, + "Workflows$StartWorkflowActivity": func(r map[string]any) workflows.WorkflowActivity { return parseStartWorkflowActivity(r) }, + "Workflows$EndOfParallelSplitPathActivity": func(r map[string]any) workflows.WorkflowActivity { + a := &workflows.EndOfParallelSplitPathActivity{} + parseBaseActivity(&a.BaseWorkflowActivity, r) + return a + }, + "Workflows$EndOfBoundaryEventPathActivity": func(r map[string]any) workflows.WorkflowActivity { + a := &workflows.EndOfBoundaryEventPathActivity{} + parseBaseActivity(&a.BaseWorkflowActivity, r) + return a + }, + "Workflows$Annotation": func(r map[string]any) workflows.WorkflowActivity { + a := &workflows.WorkflowAnnotationActivity{} + parseBaseActivity(&a.BaseWorkflowActivity, r) + if desc, ok := r["Description"].(string); ok { + a.Description = desc + } + return a + }, "Workflows$SystemTask": func(r map[string]any) workflows.WorkflowActivity { return parseSystemTask(r) }, } } @@ -198,6 +233,12 @@ func parseWorkflowActivity(raw map[string]any) workflows.WorkflowActivity { } // parseEndWorkflowActivity parses an EndWorkflowActivity. +func parseStartWorkflowActivity(raw map[string]any) *workflows.StartWorkflowActivity { + a := &workflows.StartWorkflowActivity{} + parseBaseActivity(&a.BaseWorkflowActivity, raw) + return a +} + func parseEndWorkflowActivity(raw map[string]any) *workflows.EndWorkflowActivity { a := &workflows.EndWorkflowActivity{} parseBaseActivity(&a.BaseWorkflowActivity, raw) @@ -213,9 +254,15 @@ func parseUserTask(raw map[string]any) *workflows.UserTask { if page, ok := raw["Page"].(string); ok { a.Page = page } - // Also try TaskPage - if page, ok := raw["TaskPage"].(string); ok && a.Page == "" { - a.Page = page + // Also try TaskPage — may be a nested Workflows$PageReference object + if a.Page == "" { + if page, ok := raw["TaskPage"].(string); ok { + a.Page = page + } else if taskPageMap := toMap(raw["TaskPage"]); taskPageMap != nil { + if page, ok := taskPageMap["Page"].(string); ok { + a.Page = page + } + } } // TaskName (StringTemplate) @@ -257,6 +304,9 @@ func parseUserTask(raw map[string]any) *workflows.UserTask { } } + // BoundaryEvents + a.BoundaryEvents = parseBoundaryEvents(raw["BoundaryEvents"]) + return a } @@ -301,6 +351,9 @@ func parseCallMicroflowTask(raw map[string]any) *workflows.CallMicroflowTask { // ParameterMappings a.ParameterMappings = parseParameterMappings(raw["ParameterMappings"]) + // BoundaryEvents + a.BoundaryEvents = parseBoundaryEvents(raw["BoundaryEvents"]) + return a } @@ -322,6 +375,9 @@ func parseCallWorkflowActivity(raw map[string]any) *workflows.CallWorkflowActivi a.ParameterExpression = expr } + // BoundaryEvents + a.BoundaryEvents = parseBoundaryEvents(raw["BoundaryEvents"]) + return a } @@ -385,7 +441,10 @@ func parseWaitForTimerActivity(raw map[string]any) *workflows.WaitForTimerActivi a := &workflows.WaitForTimerActivity{} parseBaseActivity(&a.BaseWorkflowActivity, raw) - if expr, ok := raw["DelayExpression"].(string); ok { + if expr, ok := raw["Delay"].(string); ok { + a.DelayExpression = expr + } else if expr, ok := raw["DelayExpression"].(string); ok { + // Legacy fallback a.DelayExpression = expr } @@ -396,6 +455,10 @@ func parseWaitForTimerActivity(raw map[string]any) *workflows.WaitForTimerActivi func parseWaitForNotificationActivity(raw map[string]any) *workflows.WaitForNotificationActivity { a := &workflows.WaitForNotificationActivity{} parseBaseActivity(&a.BaseWorkflowActivity, raw) + + // BoundaryEvents + a.BoundaryEvents = parseBoundaryEvents(raw["BoundaryEvents"]) + return a } @@ -417,6 +480,25 @@ func parseBaseActivity(a *workflows.BaseWorkflowActivity, raw map[string]any) { if caption, ok := raw["Caption"].(string); ok { a.Caption = caption } + + // Annotation (PART — Workflows$Annotation) + if annotRaw := raw["Annotation"]; annotRaw != nil { + annotMap := toMap(annotRaw) + if annotMap != nil { + if desc, ok := annotMap["Description"].(string); ok { + a.Annotation = desc + } + } + } +} + +// parseMultiUserTask parses a MultiUserTaskActivity, reusing parseUserTask with IsMulti flag. +func parseMultiUserTask(raw map[string]any) *workflows.UserTask { + task := parseUserTask(raw) + if task != nil { + task.IsMulti = true + } + return task } // parseUserTaskOutcome parses a UserTaskOutcome. @@ -430,6 +512,9 @@ func parseUserTaskOutcome(raw map[string]any) *workflows.UserTaskOutcome { if caption, ok := raw["Caption"].(string); ok { outcome.Caption = caption } + if value, ok := raw["Value"].(string); ok { + outcome.Value = value + } if flowRaw := raw["Flow"]; flowRaw != nil { outcome.Flow = parseWorkflowFlow(toMap(flowRaw)) @@ -520,6 +605,67 @@ func parseUserSource(raw map[string]any) workflows.UserSource { } } +// parseBoundaryEvents parses boundary events from a BSON array. +func parseBoundaryEvents(v any) []*workflows.BoundaryEvent { + eventsRaw := extractBsonArray(v) + var events []*workflows.BoundaryEvent + + for _, eventRaw := range eventsRaw { + eventMap := toMap(eventRaw) + if eventMap == nil { + continue + } + event := &workflows.BoundaryEvent{} + event.ID = model.ID(extractBsonID(eventMap["$ID"])) + event.TypeName = extractString(eventMap["$Type"]) + + if caption, ok := eventMap["Caption"].(string); ok { + event.Caption = caption + } + + // Timer delay — BSON field is "FirstExecutionTime" for both boundary event types + if delay, ok := eventMap["FirstExecutionTime"].(string); ok { + event.TimerDelay = delay + } + // Legacy fallbacks + if event.TimerDelay == "" { + if delay, ok := eventMap["DelayExpression"].(string); ok { + event.TimerDelay = delay + } + } + if event.TimerDelay == "" { + if delay, ok := eventMap["Delay"].(string); ok { + event.TimerDelay = delay + } + } + + // Event type from $Type + typeName := extractString(eventMap["$Type"]) + switch typeName { + case "Workflows$InterruptingTimerBoundaryEvent": + event.EventType = "InterruptingTimer" + case "Workflows$NonInterruptingTimerBoundaryEvent": + event.EventType = "NonInterruptingTimer" + case "Workflows$TimerBoundaryEvent": + event.EventType = "Timer" + default: + if typeName != "" { + // Extract the event type from the type name + event.EventType = strings.TrimPrefix(typeName, "Workflows$") + } + } + + // Flow + if flowRaw := eventMap["Flow"]; flowRaw != nil { + event.Flow = parseWorkflowFlow(toMap(flowRaw)) + } + + events = append(events, event) + } + + return events +} + // parseParameterMappings parses parameter mappings from an array. func parseParameterMappings(v any) []*workflows.ParameterMapping { mappingsRaw := extractBsonArray(v) diff --git a/sdk/mpr/reader_units.go b/sdk/mpr/reader_units.go index 1332c42..f018e44 100644 --- a/sdk/mpr/reader_units.go +++ b/sdk/mpr/reader_units.go @@ -251,6 +251,8 @@ func (r *Reader) GetRawUnitByName(objectType, qualifiedName string) (*RawUnitInf typePrefix = "Forms$Snippet" case "layout": typePrefix = "Forms$Layout" + case "workflow": + typePrefix = "Workflows$Workflow" default: return nil, fmt.Errorf("unsupported object type: %s", objectType) } @@ -396,6 +398,8 @@ func (r *Reader) ListRawUnits(objectType string) ([]*RawUnitInfo, error) { typePrefix = "Forms$Snippet" case "layout": typePrefix = "Forms$Layout" + case "workflow": + typePrefix = "Workflows$Workflow" case "": typePrefix = "" default: diff --git a/sdk/mpr/testdata/workflows/WorkflowBaseline.Sub_Workflow.bson b/sdk/mpr/testdata/workflows/WorkflowBaseline.Sub_Workflow.bson new file mode 100644 index 0000000..19251a0 Binary files /dev/null and b/sdk/mpr/testdata/workflows/WorkflowBaseline.Sub_Workflow.bson differ diff --git a/sdk/mpr/testdata/workflows/WorkflowBaseline.Workflow.bson b/sdk/mpr/testdata/workflows/WorkflowBaseline.Workflow.bson new file mode 100644 index 0000000..5710694 Binary files /dev/null and b/sdk/mpr/testdata/workflows/WorkflowBaseline.Workflow.bson differ diff --git a/sdk/mpr/workflow_parse_test.go b/sdk/mpr/workflow_parse_test.go new file mode 100644 index 0000000..7a1cbf7 --- /dev/null +++ b/sdk/mpr/workflow_parse_test.go @@ -0,0 +1,243 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpr + +import ( + "os" + "path/filepath" + "testing" + + "github.com/mendixlabs/mxcli/sdk/workflows" + "go.mongodb.org/mongo-driver/bson" +) + +// loadWorkflowBSON loads a workflow BSON fixture from testdata/workflows/.bson. +func loadWorkflowBSON(t *testing.T, name string) map[string]any { + t.Helper() + data, err := os.ReadFile(filepath.Join("testdata", "workflows", name+".bson")) + if err != nil { + t.Fatalf("load fixture %s: %v", name, err) + } + var raw map[string]any + if err := bson.Unmarshal(data, &raw); err != nil { + t.Fatalf("unmarshal fixture %s: %v", name, err) + } + return raw +} + +// workflowActivities returns the activity slice (skipping the array marker) from a flow map. +func workflowActivities(t *testing.T, flowRaw map[string]any) []map[string]any { + t.Helper() + arr, ok := flowRaw["Activities"].(bson.A) + if !ok { + t.Fatalf("Activities is not bson.A, got %T", flowRaw["Activities"]) + } + var acts []map[string]any + for _, item := range arr[1:] { // skip marker at index 0 + m := toMap(item) + if m != nil { + acts = append(acts, m) + } + } + return acts +} + +func TestParseWorkflowParameter_FromFixture(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + paramRaw := toMap(raw["Parameter"]) + if paramRaw == nil { + t.Fatal("fixture has no Parameter") + } + + param := parseWorkflowParameter(paramRaw) + if param == nil { + t.Fatal("parseWorkflowParameter returned nil") + } + if param.EntityRef != "WorkflowBaseline.Entity" { + t.Errorf("EntityRef = %q, want %q", param.EntityRef, "WorkflowBaseline.Entity") + } +} + +func TestParseWorkflowFlow_FromFixture_ActivityCount(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + if flowRaw == nil { + t.Fatal("fixture has no Flow") + } + + flow := parseWorkflowFlow(flowRaw) + if flow == nil { + t.Fatal("parseWorkflowFlow returned nil") + } + // Fixture has: Start, SingleUserTask, MultiUserTask, CallMicroflow, ParallelSplit, ExclusiveSplit, End + if len(flow.Activities) != 7 { + t.Errorf("len(Activities) = %d, want 7", len(flow.Activities)) + } +} + +func TestParseWorkflowActivity_FromFixture_StartIsFirst(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + acts := workflowActivities(t, flowRaw) + + activity := parseWorkflowActivity(acts[0]) + if _, ok := activity.(*workflows.StartWorkflowActivity); !ok { + t.Errorf("activities[0] = %T, want *workflows.StartWorkflowActivity", activity) + } +} + +func TestParseWorkflowActivity_FromFixture_UserTask(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + acts := workflowActivities(t, flowRaw) + + // activities[1] is SingleUserTaskActivity in fixture + activity := parseWorkflowActivity(acts[1]) + userTask, ok := activity.(*workflows.UserTask) + if !ok { + t.Fatalf("activities[1] = %T, want *workflows.UserTask", activity) + } + if userTask.Name != "userTask1" { + t.Errorf("Name = %q, want %q", userTask.Name, "userTask1") + } +} + +func TestParseWorkflowActivity_FromFixture_CallMicroflow(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + acts := workflowActivities(t, flowRaw) + + // activities[3] is CallMicroflowTask in fixture + activity := parseWorkflowActivity(acts[3]) + callMf, ok := activity.(*workflows.CallMicroflowTask) + if !ok { + t.Fatalf("activities[3] = %T, want *workflows.CallMicroflowTask", activity) + } + if callMf.Microflow != "WorkflowBaseline.Microflow" { + t.Errorf("Microflow = %q, want %q", callMf.Microflow, "WorkflowBaseline.Microflow") + } +} + +func TestParseWorkflowActivity_FromFixture_EndIsLast(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + acts := workflowActivities(t, flowRaw) + + last := parseWorkflowActivity(acts[len(acts)-1]) + if _, ok := last.(*workflows.EndWorkflowActivity); !ok { + t.Errorf("last activity = %T, want *workflows.EndWorkflowActivity", last) + } +} + +func TestParseUserTaskOutcome_FromFixture(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + acts := workflowActivities(t, flowRaw) + + // activities[1] is SingleUserTaskActivity with one outcome + outcomesRaw := acts[1]["Outcomes"] + arr, ok := outcomesRaw.(bson.A) + if !ok || len(arr) < 2 { + t.Fatalf("expected Outcomes array with marker+1 element, got %T len=%d", outcomesRaw, len(arr)) + } + outcomeMap := toMap(arr[1]) // skip marker + if outcomeMap == nil { + t.Fatal("outcome element is nil") + } + + outcome := parseUserTaskOutcome(outcomeMap) + if outcome == nil { + t.Fatal("parseUserTaskOutcome returned nil") + } + if outcome.Value != "Outcome" { + t.Errorf("Value = %q, want %q", outcome.Value, "Outcome") + } +} + +func TestParseParameterMappings_FromFixture(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + acts := workflowActivities(t, flowRaw) + + // activities[3] is CallMicroflowTask with 1 parameter mapping + mappingsRaw := acts[3]["ParameterMappings"] + mappings := parseParameterMappings(mappingsRaw) + if len(mappings) != 1 { + t.Fatalf("len(mappings) = %d, want 1", len(mappings)) + } +} + +func TestParseWorkflowFlow_FromFixture_SubWorkflow(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Sub_Workflow") + flowRaw := toMap(raw["Flow"]) + if flowRaw == nil { + t.Fatal("Sub_Workflow fixture has no Flow") + } + + flow := parseWorkflowFlow(flowRaw) + if flow == nil { + t.Fatal("parseWorkflowFlow returned nil") + } + if len(flow.Activities) != 2 { + t.Errorf("Sub_Workflow has %d activities, want exactly 2 (Start+End)", len(flow.Activities)) + } +} + +func TestParseWorkflowParameter_Nil(t *testing.T) { + param := parseWorkflowParameter(nil) + if param != nil { + t.Errorf("parseWorkflowParameter(nil) = %v, want nil", param) + } +} + +func TestParseWorkflowActivity_UnknownType(t *testing.T) { + raw := map[string]any{ + "$Type": "Workflows$SomeUnknownFutureActivity", + "$ID": "abc123", + "Name": "mystery", + } + activity := parseWorkflowActivity(raw) + generic, ok := activity.(*workflows.GenericWorkflowActivity) + if !ok { + t.Fatalf("unknown type = %T, want *workflows.GenericWorkflowActivity", activity) + } + if generic.Name != "mystery" { + t.Errorf("Name = %q, want %q", generic.Name, "mystery") + } +} + +func TestParseBoundaryEvents_EmptyArray(t *testing.T) { + // nil input + events := parseBoundaryEvents(nil) + if len(events) != 0 { + t.Errorf("parseBoundaryEvents(nil) len = %d, want 0", len(events)) + } + // marker-only array (bson.A with just the int32 marker) + events = parseBoundaryEvents(bson.A{int32(2)}) + if len(events) != 0 { + t.Errorf("parseBoundaryEvents(marker-only) len = %d, want 0", len(events)) + } +} + +func TestParseBoundaryEvents_TimerEvent(t *testing.T) { + eventMap := map[string]any{ + "$Type": "Workflows$InterruptingTimerBoundaryEvent", + "$ID": "be-001", + "Caption": "Timeout", + "FirstExecutionTime": "PT1H", + } + events := parseBoundaryEvents(bson.A{int32(2), eventMap}) + if len(events) != 1 { + t.Fatalf("len(events) = %d, want 1", len(events)) + } + ev := events[0] + if ev.EventType != "InterruptingTimer" { + t.Errorf("EventType = %q, want %q", ev.EventType, "InterruptingTimer") + } + if ev.TimerDelay != "PT1H" { + t.Errorf("TimerDelay = %q, want %q", ev.TimerDelay, "PT1H") + } + if ev.Caption != "Timeout" { + t.Errorf("Caption = %q, want %q", ev.Caption, "Timeout") + } +} diff --git a/sdk/mpr/workflow_write_test.go b/sdk/mpr/workflow_write_test.go new file mode 100644 index 0000000..3d93931 --- /dev/null +++ b/sdk/mpr/workflow_write_test.go @@ -0,0 +1,368 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpr + +import ( + "testing" + + "github.com/mendixlabs/mxcli/model" + "github.com/mendixlabs/mxcli/sdk/workflows" + "go.mongodb.org/mongo-driver/bson" +) + +func getBSONField(doc bson.D, key string) any { + for _, e := range doc { + if e.Key == key { + return e.Value + } + } + return nil +} + +func assertArrayMarker(t *testing.T, doc bson.D, field string, wantMarker int32) { + t.Helper() + arr, ok := getBSONField(doc, field).(bson.A) + if !ok { + t.Fatalf("%s is not bson.A", field) + } + if len(arr) == 0 { + t.Fatalf("%s is empty", field) + } + marker, ok := arr[0].(int32) + if !ok { + t.Fatalf("%s[0] is %T, want int32", field, arr[0]) + } + if marker != wantMarker { + t.Errorf("%s[0] = %d, want %d", field, marker, wantMarker) + } +} + +// --- Array marker tests: verify correct int32 markers prevent CE errors --- + +func TestSerializeWorkflowFlow_ActivitiesMarker(t *testing.T) { + flow := &workflows.Flow{ + BaseElement: model.BaseElement{ID: "flow-1"}, + Activities: []workflows.WorkflowActivity{ + &workflows.StartWorkflowActivity{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "start-1"}, + Name: "Start", + }, + }, + }, + } + doc := serializeWorkflowFlow(flow) + assertArrayMarker(t, doc, "Activities", int32(3)) +} + +func TestSerializeWorkflowFlow_EmptyActivities(t *testing.T) { + flow := &workflows.Flow{BaseElement: model.BaseElement{ID: "flow-empty"}} + doc := serializeWorkflowFlow(flow) + assertArrayMarker(t, doc, "Activities", int32(3)) + arr := getBSONField(doc, "Activities").(bson.A) + if len(arr) != 1 { + t.Errorf("empty Activities length = %d, want 1 (marker only)", len(arr)) + } +} + +func TestSerializeUserTask_OutcomesMarker(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "ut-1"}, + Name: "ReviewTask", + }, + Outcomes: []*workflows.UserTaskOutcome{ + {BaseElement: model.BaseElement{ID: "out-1"}, Value: "Approve"}, + }, + } + doc := serializeUserTask(task) + assertArrayMarker(t, doc, "Outcomes", int32(3)) +} + +func TestSerializeUserTask_BoundaryEventsMarker(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "ut-2"}, + Name: "Task", + }, + } + doc := serializeUserTask(task) + assertArrayMarker(t, doc, "BoundaryEvents", int32(2)) +} + +func TestSerializeCallMicroflowTask_ParameterMappingsMarker(t *testing.T) { + task := &workflows.CallMicroflowTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "cmt-1"}, + Name: "CallMF", + }, + Microflow: "MyModule.DoSomething", + ParameterMappings: []*workflows.ParameterMapping{ + {BaseElement: model.BaseElement{ID: "pm-1"}, Parameter: "InputParam", Expression: "$WorkflowContext"}, + }, + } + doc := serializeCallMicroflowTask(task) + assertArrayMarker(t, doc, "ParameterMappings", int32(2)) +} + +func TestSerializeUserTaskOutcome_ValueField(t *testing.T) { + outcome := &workflows.UserTaskOutcome{ + BaseElement: model.BaseElement{ID: "uto-1"}, + Value: "Approve", + } + doc := serializeUserTaskOutcome(outcome) + + if getBSONField(doc, "Value") != "Approve" { + t.Errorf("Value = %v, want %q", getBSONField(doc, "Value"), "Approve") + } + if getBSONField(doc, "Caption") != nil { + t.Error("UserTaskOutcome must not have 'Caption' key") + } + if getBSONField(doc, "Name") != nil { + t.Error("UserTaskOutcome must not have 'Name' key") + } +} + +func TestSerializeWorkflowParameter_EntityAsString(t *testing.T) { + param := &workflows.WorkflowParameter{ + BaseElement: model.BaseElement{ID: "param-1"}, + EntityRef: "MyModule.Customer", + } + doc := serializeWorkflowParameter(param) + + entity, ok := getBSONField(doc, "Entity").(string) + if !ok { + t.Fatalf("Entity is %T, want string", getBSONField(doc, "Entity")) + } + if entity != "MyModule.Customer" { + t.Errorf("Entity = %q, want %q", entity, "MyModule.Customer") + } +} + +// --- P0 bug regression tests --- + +func TestSerializeUserTask_AutoAssignSingleTargetUserDefaultsFalse(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "ut-auto"}, + Name: "Task", + }, + } + doc := serializeUserTask(task) + val := getBSONField(doc, "AutoAssignSingleTargetUser") + if val != false { + t.Errorf("AutoAssignSingleTargetUser = %v, want false", val) + } +} + +func TestSerializeUserTask_DueDateUsedFromStruct(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "ut-due"}, + Name: "Task", + }, + DueDate: "addDays([%CurrentDateTime%], 7)", + } + doc := serializeUserTask(task) + val, _ := getBSONField(doc, "DueDate").(string) + if val != "addDays([%CurrentDateTime%], 7)" { + t.Errorf("DueDate = %q, want %q", val, "addDays([%CurrentDateTime%], 7)") + } +} + +func TestSerializeBoundaryEvents_NonInterruptingTimerHasRecurrenceNull(t *testing.T) { + events := []*workflows.BoundaryEvent{ + { + BaseElement: model.BaseElement{ID: "be-1"}, + EventType: "NonInterruptingTimer", + TimerDelay: "addDays([%CurrentDateTime%], 1)", + }, + } + arr := serializeBoundaryEvents(events) + // arr[0] is int32(2) marker, arr[1] is the event doc + if len(arr) < 2 { + t.Fatal("expected 2 elements in boundary events array") + } + doc, ok := arr[1].(bson.D) + if !ok { + t.Fatalf("arr[1] is %T, want bson.D", arr[1]) + } + // Recurrence must exist with nil value + found := false + for _, e := range doc { + if e.Key == "Recurrence" { + found = true + if e.Value != nil { + t.Errorf("Recurrence = %v, want nil", e.Value) + } + } + } + if !found { + t.Error("Recurrence field missing from NonInterruptingTimerBoundaryEvent") + } +} + +// --- P1: Multi-User Task missing fields --- + +func TestSerializeMultiUserTask_AwaitAllUsersPresentAndFalse(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "mut-1"}, + Name: "MultiTask", + }, + IsMulti: true, + } + doc := serializeUserTask(task) + val := getBSONField(doc, "AwaitAllUsers") + if val == nil { + t.Error("AwaitAllUsers field missing from MultiUserTaskActivity") + return + } + if val != false { + t.Errorf("AwaitAllUsers = %v, want false", val) + } +} + +func TestSerializeMultiUserTask_TargetUserInputPresent(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "mut-2"}, + Name: "MultiTask", + }, + IsMulti: true, + } + doc := serializeUserTask(task) + val := getBSONField(doc, "TargetUserInput") + if val == nil { + t.Error("TargetUserInput field missing from MultiUserTaskActivity") + return + } + tui, ok := val.(bson.D) + if !ok { + t.Fatalf("TargetUserInput is %T, want bson.D", val) + } + typeVal, _ := getBSONField(tui, "$Type").(string) + if typeVal != "Workflows$AllUserInput" { + t.Errorf("TargetUserInput.$Type = %q, want %q", typeVal, "Workflows$AllUserInput") + } +} + +func TestSerializeMultiUserTask_CompletionCriteriaPresent(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "mut-3"}, + Name: "MultiTask", + }, + IsMulti: true, + Outcomes: []*workflows.UserTaskOutcome{ + {BaseElement: model.BaseElement{ID: "out-a"}, Value: "Approve"}, + }, + } + doc := serializeUserTask(task) + val := getBSONField(doc, "CompletionCriteria") + if val == nil { + t.Error("CompletionCriteria field missing from MultiUserTaskActivity") + return + } + cc, ok := val.(bson.D) + if !ok { + t.Fatalf("CompletionCriteria is %T, want bson.D", val) + } + typeVal, _ := getBSONField(cc, "$Type").(string) + if typeVal != "Workflows$ConsensusCompletionCriteria" { + t.Errorf("CompletionCriteria.$Type = %q, want %q", typeVal, "Workflows$ConsensusCompletionCriteria") + } + // FallbackOutcomePointer must be a UUID binary + ptr := getBSONField(cc, "FallbackOutcomePointer") + if ptr == nil { + t.Error("CompletionCriteria.FallbackOutcomePointer missing") + } +} + +func TestSerializeSingleUserTask_NoMultiFields(t *testing.T) { + task := &workflows.UserTask{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "sut-1"}, + Name: "SingleTask", + }, + IsMulti: false, + } + doc := serializeUserTask(task) + if getBSONField(doc, "AwaitAllUsers") != nil { + t.Error("SingleUserTask must not have AwaitAllUsers field") + } + if getBSONField(doc, "CompletionCriteria") != nil { + t.Error("SingleUserTask must not have CompletionCriteria field") + } + if getBSONField(doc, "TargetUserInput") != nil { + t.Error("SingleUserTask must not have TargetUserInput field") + } +} + +// --- P2: CallWorkflowActivity must not emit ParameterExpression --- + +func TestSerializeCallWorkflowActivity_NoParameterExpressionField(t *testing.T) { + act := &workflows.CallWorkflowActivity{ + BaseWorkflowActivity: workflows.BaseWorkflowActivity{ + BaseElement: model.BaseElement{ID: "cwa-1"}, + Name: "callWorkflow1", + }, + Workflow: "MyModule.SubFlow", + ParameterExpression: "$WorkflowContext", + } + doc := serializeCallWorkflowActivity(act) + for _, e := range doc { + if e.Key == "ParameterExpression" { + t.Error("CallWorkflowActivity must not emit ParameterExpression field (not in Studio Pro BSON)") + return + } + } +} + +// --- Fixture-based roundtrip: parse real BSON → serialize → verify markers preserved --- + +func TestSerializeWorkflowFlow_RoundtripFromFixture(t *testing.T) { + raw := loadWorkflowBSON(t, "WorkflowBaseline.Workflow") + flowRaw := toMap(raw["Flow"]) + if flowRaw == nil { + t.Fatal("fixture has no Flow") + } + + // Parse real workflow from fixture + flow := parseWorkflowFlow(flowRaw) + if flow == nil { + t.Fatal("parseWorkflowFlow returned nil") + } + + // Serialize back to BSON + doc := serializeWorkflowFlow(flow) + + // Verify array markers survive the roundtrip + assertArrayMarker(t, doc, "Activities", int32(3)) + + // Re-marshal and re-parse to verify full roundtrip + data, err := bson.Marshal(doc) + if err != nil { + t.Fatalf("marshal: %v", err) + } + var reparsedRaw map[string]any + if err := bson.Unmarshal(data, &reparsedRaw); err != nil { + t.Fatalf("unmarshal: %v", err) + } + reparsed := parseWorkflowFlow(reparsedRaw) + if reparsed == nil { + t.Fatal("re-parse returned nil") + } + if len(reparsed.Activities) != len(flow.Activities) { + t.Errorf("roundtrip Activities count = %d, want %d", len(reparsed.Activities), len(flow.Activities)) + } + // Verify first activity type is preserved + if _, ok := reparsed.Activities[0].(*workflows.StartWorkflowActivity); !ok { + t.Errorf("roundtrip Activities[0] = %T, want *workflows.StartWorkflowActivity", reparsed.Activities[0]) + } + // Verify last activity type is preserved + last := reparsed.Activities[len(reparsed.Activities)-1] + if _, ok := last.(*workflows.EndWorkflowActivity); !ok { + t.Errorf("roundtrip last activity = %T, want *workflows.EndWorkflowActivity", last) + } +} diff --git a/sdk/mpr/writer_domainmodel.go b/sdk/mpr/writer_domainmodel.go index 5424ae5..90d946d 100644 --- a/sdk/mpr/writer_domainmodel.go +++ b/sdk/mpr/writer_domainmodel.go @@ -811,7 +811,7 @@ func serializeAttribute(a *domainmodel.Attribute) bson.D { } } - // Determine value type: OqlViewValue for view entities, StoredValue for regular entities + // Determine value type: OqlViewValue, CalculatedValue, or StoredValue var valueDoc bson.D valueID := "" if a.Value != nil && a.Value.ID != "" { @@ -827,6 +827,15 @@ func serializeAttribute(a *domainmodel.Attribute) bson.D { {Key: "$Type", Value: "DomainModels$OqlViewValue"}, {Key: "Reference", Value: a.Value.ViewReference}, } + } else if a.Value != nil && a.Value.Type == "CalculatedValue" { + // Calculated attribute - use CalculatedValue (Microflow is ByNameReference → string) + microflowRef := a.Value.MicroflowName + valueDoc = bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "DomainModels$CalculatedValue"}, + {Key: "Microflow", Value: microflowRef}, + {Key: "PassEntity", Value: microflowRef != ""}, + } } else { // Regular entity attribute - use StoredValue defaultValue := "" diff --git a/sdk/mpr/writer_microflow.go b/sdk/mpr/writer_microflow.go index 37cd75b..ba8a0c3 100644 --- a/sdk/mpr/writer_microflow.go +++ b/sdk/mpr/writer_microflow.go @@ -458,20 +458,24 @@ func serializeMicroflowObject(obj microflows.MicroflowObject) bson.D { {Key: "ErrorHandlingType", Value: string(o.ErrorHandlingType)}, } // Serialize LoopSource (IterableList or WhileLoopCondition) - switch ls := o.LoopSource.(type) { - case *microflows.IterableList: - doc = append(doc, bson.E{Key: "LoopSource", Value: bson.D{ - {Key: "$ID", Value: idToBsonBinary(string(ls.ID))}, - {Key: "$Type", Value: "Microflows$IterableList"}, - {Key: "ListVariableName", Value: ls.ListVariableName}, - {Key: "VariableName", Value: ls.VariableName}, - }}) - case *microflows.WhileLoopCondition: - doc = append(doc, bson.E{Key: "LoopSource", Value: bson.D{ - {Key: "$ID", Value: idToBsonBinary(string(ls.ID))}, - {Key: "$Type", Value: "Microflows$WhileLoopCondition"}, - {Key: "WhileExpression", Value: ls.WhileExpression}, - }}) + if o.LoopSource != nil { + switch ls := o.LoopSource.(type) { + case *microflows.IterableList: + loopSource := bson.D{ + {Key: "$ID", Value: idToBsonBinary(string(ls.ID))}, + {Key: "$Type", Value: "Microflows$IterableList"}, + {Key: "ListVariableName", Value: ls.ListVariableName}, + {Key: "VariableName", Value: ls.VariableName}, + } + doc = append(doc, bson.E{Key: "LoopSource", Value: loopSource}) + case *microflows.WhileLoopCondition: + loopSource := bson.D{ + {Key: "$ID", Value: idToBsonBinary(string(ls.ID))}, + {Key: "$Type", Value: "Microflows$WhileLoopCondition"}, + {Key: "WhileExpression", Value: ls.WhileExpression}, + } + doc = append(doc, bson.E{Key: "LoopSource", Value: loopSource}) + } } // Serialize nested ObjectCollection if o.ObjectCollection != nil { @@ -509,16 +513,12 @@ func serializeMicroflowObject(obj microflows.MicroflowObject) bson.D { } case *model.UnknownElement: - // Write-through: serialize RawFields back as-is so unknown activities + // Write-through: serialize RawDoc back as-is so unknown activities // are not silently dropped when the MPR is saved. - if o.RawFields == nil { + if o.RawDoc == nil { return nil } - doc := make(bson.D, 0, len(o.RawFields)) - for k, v := range o.RawFields { - doc = append(doc, bson.E{Key: k, Value: v}) - } - return doc + return o.RawDoc default: return nil diff --git a/sdk/mpr/writer_security.go b/sdk/mpr/writer_security.go index e8a5a88..f7fbeba 100644 --- a/sdk/mpr/writer_security.go +++ b/sdk/mpr/writer_security.go @@ -379,14 +379,14 @@ func (w *Writer) RemoveUserRole(unitID model.ID, name string) error { } // AddDemoUser adds a new demo user to Security$ProjectSecurity. -func (w *Writer) AddDemoUser(unitID model.ID, userName, password string, userRoles []string) error { +func (w *Writer) AddDemoUser(unitID model.ID, userName, password, entity string, userRoles []string) error { return w.readPatchWrite(unitID, func(doc bson.D) (bson.D, error) { newUser := bson.D{ {Key: "$Type", Value: "Security$DemoUserImpl"}, {Key: "$ID", Value: idToBsonBinary(generateUUID())}, {Key: "UserName", Value: userName}, {Key: "Password", Value: password}, - {Key: "Entity", Value: ""}, + {Key: "Entity", Value: entity}, {Key: "UserRoles", Value: makeMendixStringArray(userRoles)}, } @@ -862,20 +862,37 @@ func (w *Writer) ReconcileMemberAccesses(unitID model.ID, moduleName string) (in continue } - // Collect current attribute names + // Collect current attribute names and track calculated attributes attrNames := map[string]bool{} + calculatedAttrs := map[string]bool{} attrsArr := getBsonArray(entityDoc, "Attributes") for _, attrItem := range attrsArr { attrDoc, ok := attrItem.(bson.D) if !ok { continue } + attrName := "" + isCalculated := false for _, f := range attrDoc { if f.Key == "Name" { - if name, ok := f.Value.(string); ok { - attrNames[name] = true + attrName, _ = f.Value.(string) + } + if f.Key == "Value" { + if valueDoc, ok := f.Value.(bson.D); ok { + for _, vf := range valueDoc { + if vf.Key == "$Type" { + if vt, ok := vf.Value.(string); ok && vt == "DomainModels$CalculatedValue" { + isCalculated = true + } + } + } } - break + } + } + if attrName != "" { + attrNames[attrName] = true + if isCalculated { + calculatedAttrs[attrName] = true } } } @@ -1010,7 +1027,11 @@ func (w *Writer) ReconcileMemberAccesses(unitID model.ID, moduleName string) (in parts := splitQualifiedRef(attrRef) if parts != "" && attrNames[parts] { coveredAttrs[parts] = true - filtered = append(filtered, maItem) + // Downgrade write rights on calculated attributes (CE6592) + if calculatedAttrs[parts] { + maDoc = downgradeCalculatedAttrRights(maDoc) + } + filtered = append(filtered, maDoc) } else { changed = true // stale attribute entry removed } @@ -1031,10 +1052,15 @@ func (w *Writer) ReconcileMemberAccesses(unitID model.ID, moduleName string) (in // Add missing attributes for attrName := range attrNames { if !coveredAttrs[attrName] { + rights := defaultRights + // Calculated attributes cannot have write rights (CE6592) + if calculatedAttrs[attrName] && (rights == "ReadWrite" || rights == "WriteOnly") { + rights = "ReadOnly" + } newMA := bson.D{ {Key: "$Type", Value: "DomainModels$MemberAccess"}, {Key: "$ID", Value: idToBsonBinary(generateUUID())}, - {Key: "AccessRights", Value: defaultRights}, + {Key: "AccessRights", Value: rights}, {Key: "Attribute", Value: moduleName + "." + entityName + "." + attrName}, } filtered = append(filtered, newMA) @@ -1079,6 +1105,18 @@ func (w *Writer) ReconcileMemberAccesses(unitID model.ID, moduleName string) (in return modified, err } +// downgradeCalculatedAttrRights changes ReadWrite/WriteOnly to ReadOnly on a MemberAccess doc. +func downgradeCalculatedAttrRights(doc bson.D) bson.D { + for i, f := range doc { + if f.Key == "AccessRights" { + if rights, ok := f.Value.(string); ok && (rights == "ReadWrite" || rights == "WriteOnly") { + doc[i].Value = "ReadOnly" + } + } + } + return doc +} + // extractBsonIDValue extracts a string ID from various BSON ID representations. func extractBsonIDValue(v any) string { switch val := v.(type) { diff --git a/sdk/mpr/writer_workflow.go b/sdk/mpr/writer_workflow.go new file mode 100644 index 0000000..3f3e2ef --- /dev/null +++ b/sdk/mpr/writer_workflow.go @@ -0,0 +1,746 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpr + +import ( + "fmt" + + "github.com/mendixlabs/mxcli/model" + "github.com/mendixlabs/mxcli/sdk/workflows" + + "go.mongodb.org/mongo-driver/bson" +) + +// CreateWorkflow creates a new workflow in the MPR. +func (w *Writer) CreateWorkflow(wf *workflows.Workflow) error { + if wf.ID == "" { + wf.ID = model.ID(generateUUID()) + } + wf.TypeName = "Workflows$Workflow" + + contents, err := w.serializeWorkflow(wf) + if err != nil { + return fmt.Errorf("failed to serialize workflow: %w", err) + } + + return w.insertUnit(string(wf.ID), string(wf.ContainerID), "Documents", "Workflows$Workflow", contents) +} + +// DeleteWorkflow deletes a workflow from the MPR. +func (w *Writer) DeleteWorkflow(id model.ID) error { + return w.deleteUnit(string(id)) +} + +func (w *Writer) serializeWorkflow(wf *workflows.Workflow) ([]byte, error) { + // AdminPage is a PartProperty (object or null), not a string. + // When empty, it must be null, not "". + var adminPageValue any + if wf.AdminPage != "" { + adminPageValue = bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$PageReference"}, + {Key: "Page", Value: wf.AdminPage}, + } + } + + // Annotation is a PartProperty (object or null). + var annotationValue any + if wf.Annotation != "" { + annotationValue = serializeAnnotation(wf.Annotation) + } + + // Flow + var flowValue bson.D + if wf.Flow != nil { + flowValue = serializeWorkflowFlow(wf.Flow) + } else { + emptyFlow := &workflows.Flow{} + emptyFlow.ID = model.ID(generateUUID()) + flowValue = serializeWorkflowFlow(emptyFlow) + } + + // Title defaults to workflow display name or Name + title := wf.WorkflowName + if title == "" { + title = wf.Name + } + + // Build doc in alphabetical key order matching Studio Pro BSON layout + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(string(wf.ID))}, + {Key: "$Type", Value: "Workflows$Workflow"}, + {Key: "AdminPage", Value: adminPageValue}, + {Key: "Annotation", Value: annotationValue}, + {Key: "Documentation", Value: wf.Documentation}, + {Key: "DueDate", Value: wf.DueDate}, + {Key: "Excluded", Value: wf.Excluded}, + {Key: "ExportLevel", Value: "Hidden"}, + {Key: "Flow", Value: flowValue}, + {Key: "Name", Value: wf.Name}, + {Key: "OnWorkflowEvent", Value: bson.A{int32(2)}}, + } + + // Parameter + if wf.Parameter != nil { + doc = append(doc, bson.E{Key: "Parameter", Value: serializeWorkflowParameter(wf.Parameter)}) + } + + doc = append(doc, + bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}, + bson.E{Key: "Title", Value: title}, + bson.E{Key: "WorkflowDescription", Value: serializeWorkflowStringTemplate(wf.WorkflowDescription)}, + bson.E{Key: "WorkflowMetaData", Value: nil}, + bson.E{Key: "WorkflowName", Value: serializeWorkflowStringTemplate(wf.WorkflowName)}, + bson.E{Key: "WorkflowV2", Value: false}, + ) + + // NOTE: OverviewPage was deleted in Mendix 9.11.0 — do not serialize it. + // NOTE: AllowedModuleRoles is not present in Studio Pro BSON — omitted. + + return bson.Marshal(doc) +} + +// serializeWorkflowStringTemplate creates a minimal Mendix StringTemplate BSON structure for workflows. +func serializeWorkflowStringTemplate(text string) bson.D { + return bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Microflows$StringTemplate"}, + {Key: "Parameters", Value: bson.A{int32(2)}}, + {Key: "Text", Value: text}, + } +} + +// serializeWorkflowParameter serializes a workflow parameter. +// Since Mendix 9.10.0, EntityRef (PartProperty) was replaced by Entity (ByNameReferenceProperty). +func serializeWorkflowParameter(param *workflows.WorkflowParameter) bson.D { + paramID := string(param.ID) + if paramID == "" { + paramID = generateUUID() + } + return bson.D{ + {Key: "$ID", Value: idToBsonBinary(paramID)}, + {Key: "$Type", Value: "Workflows$Parameter"}, + {Key: "Entity", Value: param.EntityRef}, + {Key: "Name", Value: "WorkflowContext"}, + } +} + +// serializeAnnotation serializes a workflow annotation if non-empty. +func serializeAnnotation(annotation string) bson.D { + return bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$Annotation"}, + {Key: "Description", Value: annotation}, + } +} + + +// appendActivityBaseFields appends common activity fields to a BSON doc. +// If annotation is non-empty, it serializes as an object; otherwise null. +func appendActivityBaseFields(doc bson.D, annotation string) bson.D { + var annotationValue any + if annotation != "" { + annotationValue = serializeAnnotation(annotation) + } + return append(doc, + bson.E{Key: "Annotation", Value: annotationValue}, + bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}, + bson.E{Key: "RelativeMiddlePoint", Value: ""}, + bson.E{Key: "Size", Value: ""}, + ) +} + +// serializeBoundaryEvents serializes boundary events for workflow activities. +func serializeBoundaryEvents(events []*workflows.BoundaryEvent) bson.A { + arr := bson.A{int32(2)} // array type marker (BoundaryEvents use marker 2) + for _, event := range events { + eventID := string(event.ID) + if eventID == "" { + eventID = generateUUID() + } + + typeName := "Workflows$InterruptingTimerBoundaryEvent" + switch event.EventType { + case "NonInterruptingTimer": + typeName = "Workflows$NonInterruptingTimerBoundaryEvent" + case "Timer": + typeName = "Workflows$TimerBoundaryEvent" + case "InterruptingTimer": + typeName = "Workflows$InterruptingTimerBoundaryEvent" + } + + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(eventID)}, + {Key: "$Type", Value: typeName}, + {Key: "Caption", Value: event.Caption}, + } + + if event.TimerDelay != "" { + doc = append(doc, bson.E{Key: "FirstExecutionTime", Value: event.TimerDelay}) + } + + if event.Flow != nil { + doc = append(doc, bson.E{Key: "Flow", Value: serializeWorkflowFlow(event.Flow)}) + } + + doc = append(doc, bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}) + + if typeName == "Workflows$NonInterruptingTimerBoundaryEvent" { + doc = append(doc, bson.E{Key: "Recurrence", Value: nil}) + } + + arr = append(arr, doc) + } + return arr +} + +// emptyBoundaryEvents returns an empty boundary events array marker. +func emptyBoundaryEvents() bson.A { + return bson.A{int32(2)} +} + +// serializeWorkflowFlow serializes a workflow flow with its activities. +func serializeWorkflowFlow(flow *workflows.Flow) bson.D { + flowID := string(flow.ID) + if flowID == "" { + flowID = generateUUID() + } + + activities := bson.A{int32(3)} // array type marker + for _, act := range flow.Activities { + actDoc := serializeWorkflowActivity(act) + if actDoc != nil { + activities = append(activities, actDoc) + } + } + + return bson.D{ + {Key: "$ID", Value: idToBsonBinary(flowID)}, + {Key: "$Type", Value: "Workflows$Flow"}, + {Key: "Activities", Value: activities}, + } +} + +// serializeWorkflowActivity dispatches to the correct serializer. +func serializeWorkflowActivity(act workflows.WorkflowActivity) bson.D { + switch a := act.(type) { + case *workflows.UserTask: + return serializeUserTask(a) + case *workflows.CallMicroflowTask: + return serializeCallMicroflowTask(a) + case *workflows.CallWorkflowActivity: + return serializeCallWorkflowActivity(a) + case *workflows.ExclusiveSplitActivity: + return serializeExclusiveSplit(a) + case *workflows.ParallelSplitActivity: + return serializeParallelSplit(a) + case *workflows.JumpToActivity: + return serializeJumpTo(a) + case *workflows.WaitForTimerActivity: + return serializeWaitForTimer(a) + case *workflows.WaitForNotificationActivity: + return serializeWaitForNotification(a) + case *workflows.StartWorkflowActivity: + return serializeStartWorkflow(a) + case *workflows.EndWorkflowActivity: + return serializeEndWorkflow(a) + case *workflows.WorkflowAnnotationActivity: + return serializeWorkflowAnnotationActivity(a) + default: + return nil + } +} + +func activityID(a *workflows.BaseWorkflowActivity) string { + if string(a.ID) != "" { + return string(a.ID) + } + return generateUUID() +} + +func serializeUserTask(a *workflows.UserTask) bson.D { + // UserTask was deleted in Mendix 10.12.0, replaced by SingleUserTaskActivity. + typeName := "Workflows$SingleUserTaskActivity" + if a.IsMulti { + typeName = "Workflows$MultiUserTaskActivity" + } + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: typeName}, + } + + // Annotation (null or object) + var annotationValue any + if a.Annotation != "" { + annotationValue = serializeAnnotation(a.Annotation) + } + doc = append(doc, bson.E{Key: "Annotation", Value: annotationValue}) + + // AutoAssignSingleTargetUser + doc = append(doc, bson.E{Key: "AutoAssignSingleTargetUser", Value: false}) + + // AwaitAllUsers (MultiUserTaskActivity only) + if a.IsMulti { + doc = append(doc, bson.E{Key: "AwaitAllUsers", Value: false}) + } + + // BoundaryEvents (always present, even if empty) + if len(a.BoundaryEvents) > 0 { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: serializeBoundaryEvents(a.BoundaryEvents)}) + } else { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: emptyBoundaryEvents()}) + } + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + ) + + // CompletionCriteria (MultiUserTaskActivity only) — must reference first outcome ID + if a.IsMulti { + // Pre-assign ID to first outcome so FallbackOutcomePointer can reference it + if len(a.Outcomes) > 0 && a.Outcomes[0].ID == "" { + a.Outcomes[0].ID = model.ID(generateUUID()) + } + fallbackID := "" + if len(a.Outcomes) > 0 { + fallbackID = string(a.Outcomes[0].ID) + } else { + fallbackID = generateUUID() + } + doc = append(doc, bson.E{Key: "CompletionCriteria", Value: bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$ConsensusCompletionCriteria"}, + {Key: "FallbackOutcomePointer", Value: idToBsonBinary(fallbackID)}, + }}) + } + + doc = append(doc, + bson.E{Key: "DueDate", Value: a.DueDate}, + bson.E{Key: "Name", Value: a.Name}, + ) + + // OnCreatedEvent (NoEvent) + doc = append(doc, bson.E{Key: "OnCreatedEvent", Value: bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$NoEvent"}, + }}) + + // Outcomes + outcomes := bson.A{int32(3)} + for _, outcome := range a.Outcomes { + outcomes = append(outcomes, serializeUserTaskOutcome(outcome)) + } + doc = append(doc, bson.E{Key: "Outcomes", Value: outcomes}) + + doc = append(doc, + bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}, + bson.E{Key: "RelativeMiddlePoint", Value: ""}, + bson.E{Key: "Size", Value: ""}, + ) + + // TaskDescription + doc = append(doc, bson.E{Key: "TaskDescription", Value: serializeWorkflowStringTemplate(a.TaskDescription)}) + + // TaskName + taskName := a.TaskName + if taskName == "" { + taskName = a.Caption + } + doc = append(doc, bson.E{Key: "TaskName", Value: serializeWorkflowStringTemplate(taskName)}) + + // TaskPage (PageReference - required, never null) + doc = append(doc, bson.E{Key: "TaskPage", Value: bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$PageReference"}, + {Key: "Page", Value: a.Page}, + }}) + + // TargetUserInput (MultiUserTaskActivity only) — always AllUserInput + if a.IsMulti { + doc = append(doc, bson.E{Key: "TargetUserInput", Value: bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$AllUserInput"}, + }}) + } + + // UserTargeting (NoUserTargeting when not specified) + if a.UserSource != nil { + doc = append(doc, bson.E{Key: "UserTargeting", Value: serializeUserTargeting(a.UserSource)}) + } else { + doc = append(doc, bson.E{Key: "UserTargeting", Value: bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$NoUserTargeting"}, + }}) + } + + return doc +} + +func serializeUserTargeting(source workflows.UserSource) bson.D { + switch s := source.(type) { + case *workflows.MicroflowBasedUserSource: + return bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$MicroflowUserTargeting"}, + {Key: "Microflow", Value: s.Microflow}, + } + case *workflows.XPathBasedUserSource: + return bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$XPathUserTargeting"}, + {Key: "XPathConstraint", Value: s.XPath}, + } + default: + return bson.D{ + {Key: "$ID", Value: idToBsonBinary(generateUUID())}, + {Key: "$Type", Value: "Workflows$NoUserTargeting"}, + } + } +} + +func serializeUserTaskOutcome(outcome *workflows.UserTaskOutcome) bson.D { + outcomeID := string(outcome.ID) + if outcomeID == "" { + outcomeID = generateUUID() + } + + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(outcomeID)}, + {Key: "$Type", Value: "Workflows$UserTaskOutcome"}, + } + + if outcome.Flow != nil { + doc = append(doc, bson.E{Key: "Flow", Value: serializeWorkflowFlow(outcome.Flow)}) + } + + doc = append(doc, + bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}, + bson.E{Key: "Value", Value: outcome.Value}, + ) + + return doc +} + +func serializeCallMicroflowTask(a *workflows.CallMicroflowTask) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$CallMicroflowTask"}, + } + + // Annotation + var annotationValue any + if a.Annotation != "" { + annotationValue = serializeAnnotation(a.Annotation) + } + doc = append(doc, bson.E{Key: "Annotation", Value: annotationValue}) + + // BoundaryEvents (always present) + if len(a.BoundaryEvents) > 0 { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: serializeBoundaryEvents(a.BoundaryEvents)}) + } else { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: emptyBoundaryEvents()}) + } + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Microflow", Value: a.Microflow}, + bson.E{Key: "Name", Value: a.Name}, + ) + + // Outcomes + outcomes := bson.A{int32(3)} + for _, outcome := range a.Outcomes { + outcomes = append(outcomes, serializeConditionOutcome(outcome)) + } + doc = append(doc, bson.E{Key: "Outcomes", Value: outcomes}) + + // ParameterMappings (always present) + mappings := bson.A{int32(2)} + for _, pm := range a.ParameterMappings { + pmID := string(pm.ID) + if pmID == "" { + pmID = generateUUID() + } + mappings = append(mappings, bson.D{ + {Key: "$ID", Value: idToBsonBinary(pmID)}, + {Key: "$Type", Value: "Workflows$MicroflowCallParameterMapping"}, + {Key: "Expression", Value: pm.Expression}, + {Key: "Parameter", Value: pm.Parameter}, + }) + } + doc = append(doc, bson.E{Key: "ParameterMappings", Value: mappings}) + + doc = append(doc, + bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}, + bson.E{Key: "RelativeMiddlePoint", Value: ""}, + bson.E{Key: "Size", Value: ""}, + ) + + return doc +} + +func serializeCallWorkflowActivity(a *workflows.CallWorkflowActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$CallWorkflowActivity"}, + } + + // Annotation + var annotationValue any + if a.Annotation != "" { + annotationValue = serializeAnnotation(a.Annotation) + } + doc = append(doc, bson.E{Key: "Annotation", Value: annotationValue}) + + // BoundaryEvents (always present) + if len(a.BoundaryEvents) > 0 { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: serializeBoundaryEvents(a.BoundaryEvents)}) + } else { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: emptyBoundaryEvents()}) + } + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "ExecuteAsync", Value: false}, + bson.E{Key: "Name", Value: a.Name}, + ) + + // ParameterMappings (always present, marker int32(2)) + paramMappings := bson.A{int32(2)} + for _, pm := range a.ParameterMappings { + pmID := string(pm.ID) + if pmID == "" { + pmID = generateUUID() + } + paramMappings = append(paramMappings, bson.D{ + {Key: "$ID", Value: idToBsonBinary(pmID)}, + {Key: "$Type", Value: "Workflows$WorkflowCallParameterMapping"}, + {Key: "Expression", Value: pm.Expression}, + {Key: "Parameter", Value: pm.Parameter}, + }) + } + doc = append(doc, bson.E{Key: "ParameterMappings", Value: paramMappings}) + + doc = append(doc, + bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}, + bson.E{Key: "RelativeMiddlePoint", Value: ""}, + bson.E{Key: "Size", Value: ""}, + bson.E{Key: "Workflow", Value: a.Workflow}, + ) + + return doc +} + +func serializeExclusiveSplit(a *workflows.ExclusiveSplitActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$ExclusiveSplitActivity"}, + } + + doc = appendActivityBaseFields(doc, a.Annotation) + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Expression", Value: a.Expression}, + bson.E{Key: "Name", Value: a.Name}, + ) + + outcomes := bson.A{int32(3)} + for _, outcome := range a.Outcomes { + outcomes = append(outcomes, serializeConditionOutcome(outcome)) + } + doc = append(doc, bson.E{Key: "Outcomes", Value: outcomes}) + + return doc +} + +func serializeConditionOutcome(outcome workflows.ConditionOutcome) bson.D { + switch o := outcome.(type) { + case *workflows.BooleanConditionOutcome: + outcomeID := string(o.ID) + if outcomeID == "" { + outcomeID = generateUUID() + } + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(outcomeID)}, + {Key: "$Type", Value: "Workflows$BooleanConditionOutcome"}, + {Key: "Value", Value: o.Value}, + } + if o.Flow != nil { + doc = append(doc, bson.E{Key: "Flow", Value: serializeWorkflowFlow(o.Flow)}) + } + return doc + case *workflows.EnumerationValueConditionOutcome: + outcomeID := string(o.ID) + if outcomeID == "" { + outcomeID = generateUUID() + } + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(outcomeID)}, + {Key: "$Type", Value: "Workflows$EnumerationValueConditionOutcome"}, + {Key: "Value", Value: o.Value}, + } + if o.Flow != nil { + doc = append(doc, bson.E{Key: "Flow", Value: serializeWorkflowFlow(o.Flow)}) + } + return doc + case *workflows.VoidConditionOutcome: + outcomeID := string(o.ID) + if outcomeID == "" { + outcomeID = generateUUID() + } + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(outcomeID)}, + {Key: "$Type", Value: "Workflows$VoidConditionOutcome"}, + } + if o.Flow != nil { + doc = append(doc, bson.E{Key: "Flow", Value: serializeWorkflowFlow(o.Flow)}) + } + return doc + default: + return nil + } +} + +func serializeParallelSplit(a *workflows.ParallelSplitActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$ParallelSplitActivity"}, + } + + doc = appendActivityBaseFields(doc, a.Annotation) + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Name", Value: a.Name}, + ) + + outcomes := bson.A{int32(3)} + for _, outcome := range a.Outcomes { + outcomeID := string(outcome.ID) + if outcomeID == "" { + outcomeID = generateUUID() + } + outDoc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(outcomeID)}, + {Key: "$Type", Value: "Workflows$ParallelSplitOutcome"}, + } + if outcome.Flow != nil { + outDoc = append(outDoc, bson.E{Key: "Flow", Value: serializeWorkflowFlow(outcome.Flow)}) + } + outDoc = append(outDoc, bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}) + outcomes = append(outcomes, outDoc) + } + doc = append(doc, bson.E{Key: "Outcomes", Value: outcomes}) + + return doc +} + +func serializeJumpTo(a *workflows.JumpToActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$JumpToActivity"}, + } + + doc = appendActivityBaseFields(doc, a.Annotation) + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Name", Value: a.Name}, + bson.E{Key: "TargetActivity", Value: a.TargetActivity}, + ) + + return doc +} + +func serializeWaitForTimer(a *workflows.WaitForTimerActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$WaitForTimerActivity"}, + } + + doc = appendActivityBaseFields(doc, a.Annotation) + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Delay", Value: a.DelayExpression}, + bson.E{Key: "Name", Value: a.Name}, + ) + + return doc +} + +func serializeWaitForNotification(a *workflows.WaitForNotificationActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$WaitForNotificationActivity"}, + } + + // Annotation + var annotationValue any + if a.Annotation != "" { + annotationValue = serializeAnnotation(a.Annotation) + } + doc = append(doc, bson.E{Key: "Annotation", Value: annotationValue}) + + // BoundaryEvents (always present) + if len(a.BoundaryEvents) > 0 { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: serializeBoundaryEvents(a.BoundaryEvents)}) + } else { + doc = append(doc, bson.E{Key: "BoundaryEvents", Value: emptyBoundaryEvents()}) + } + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Name", Value: a.Name}, + bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}, + bson.E{Key: "RelativeMiddlePoint", Value: ""}, + bson.E{Key: "Size", Value: ""}, + ) + + return doc +} + +func serializeStartWorkflow(a *workflows.StartWorkflowActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$StartWorkflowActivity"}, + } + + doc = appendActivityBaseFields(doc, a.Annotation) + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Name", Value: a.Name}, + ) + + return doc +} + +func serializeEndWorkflow(a *workflows.EndWorkflowActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$EndWorkflowActivity"}, + } + + doc = appendActivityBaseFields(doc, a.Annotation) + + doc = append(doc, + bson.E{Key: "Caption", Value: a.Caption}, + bson.E{Key: "Name", Value: a.Name}, + ) + + return doc +} + +func serializeWorkflowAnnotationActivity(a *workflows.WorkflowAnnotationActivity) bson.D { + doc := bson.D{ + {Key: "$ID", Value: idToBsonBinary(activityID(&a.BaseWorkflowActivity))}, + {Key: "$Type", Value: "Workflows$Annotation"}, + {Key: "Description", Value: a.Description}, + } + doc = append(doc, bson.E{Key: "PersistentId", Value: idToBsonBinary(generateUUID())}) + doc = append(doc, bson.E{Key: "RelativeMiddlePoint", Value: ""}) + doc = append(doc, bson.E{Key: "Size", Value: ""}) + return doc +} diff --git a/sdk/workflows/workflow.go b/sdk/workflows/workflow.go index 3b06240..eca06e9 100644 --- a/sdk/workflows/workflow.go +++ b/sdk/workflows/workflow.go @@ -4,6 +4,8 @@ package workflows import ( + "strings" + "github.com/mendixlabs/mxcli/model" ) @@ -21,11 +23,17 @@ type Workflow struct { DueDate string `json:"dueDate,omitempty"` // Due date expression AdminPage string `json:"adminPage,omitempty"` // Qualified name of admin page + // Annotation + Annotation string `json:"annotation,omitempty"` // Annotation description text + // Context parameter Parameter *WorkflowParameter `json:"parameter,omitempty"` // Flow contains the workflow activities Flow *Flow `json:"flow,omitempty"` + + // Allowed module roles for execution + AllowedModuleRoles []model.ID `json:"allowedModuleRoles,omitempty"` } // GetName returns the workflow's name. @@ -61,8 +69,9 @@ type WorkflowActivity interface { // BaseWorkflowActivity provides common fields for all workflow activities. type BaseWorkflowActivity struct { model.BaseElement - Name string `json:"name,omitempty"` - Caption string `json:"caption,omitempty"` + Name string `json:"name,omitempty"` + Caption string `json:"caption,omitempty"` + Annotation string `json:"annotation,omitempty"` // Annotation description text } // GetID returns the activity's ID. @@ -80,6 +89,14 @@ func (a *BaseWorkflowActivity) GetCaption() string { return a.Caption } +// StartWorkflowActivity represents the start of a workflow. +type StartWorkflowActivity struct { + BaseWorkflowActivity +} + +// ActivityType returns the type name. +func (a *StartWorkflowActivity) ActivityType() string { return "StartWorkflow" } + // EndWorkflowActivity represents the end of a workflow. type EndWorkflowActivity struct { BaseWorkflowActivity @@ -91,6 +108,7 @@ func (a *EndWorkflowActivity) ActivityType() string { return "EndWorkflow" } // UserTask represents a user task in a workflow. type UserTask struct { BaseWorkflowActivity + IsMulti bool `json:"isMulti,omitempty"` // true if Workflows$MultiUserTaskActivity Page string `json:"page,omitempty"` // Qualified name of the task page UserSource UserSource `json:"userSource,omitempty"` // Who should handle the task Outcomes []*UserTaskOutcome `json:"outcomes,omitempty"` // Task outcomes @@ -99,6 +117,7 @@ type UserTask struct { DueDate string `json:"dueDate,omitempty"` // Due date expression UserTaskEntity string `json:"userTaskEntity,omitempty"` // Qualified name of user task entity OnCreated string `json:"onCreated,omitempty"` // Microflow called on task creation + BoundaryEvents []*BoundaryEvent `json:"boundaryEvents,omitempty"` // Boundary events (e.g., timers) } // ActivityType returns the type name. @@ -121,6 +140,7 @@ type CallMicroflowTask struct { Microflow string `json:"microflow,omitempty"` // Qualified name of the microflow to call Outcomes []ConditionOutcome `json:"outcomes,omitempty"` // Condition-based outcomes ParameterMappings []*ParameterMapping `json:"parameterMappings,omitempty"` + BoundaryEvents []*BoundaryEvent `json:"boundaryEvents,omitempty"` // Boundary events (e.g., timers) } // ActivityType returns the type name. @@ -129,8 +149,10 @@ func (a *CallMicroflowTask) ActivityType() string { return "CallMicroflow" } // CallWorkflowActivity represents calling a sub-workflow. type CallWorkflowActivity struct { BaseWorkflowActivity - Workflow string `json:"workflow,omitempty"` // Qualified name of the workflow to call - ParameterExpression string `json:"parameterExpression,omitempty"` // Expression for context parameter + Workflow string `json:"workflow,omitempty"` // Qualified name of the workflow to call + ParameterExpression string `json:"parameterExpression,omitempty"` // Expression for context parameter + ParameterMappings []*ParameterMapping `json:"parameterMappings,omitempty"` // Parameter mappings for the workflow call + BoundaryEvents []*BoundaryEvent `json:"boundaryEvents,omitempty"` // Boundary events (e.g., timers) } // ActivityType returns the type name. @@ -176,11 +198,37 @@ func (a *WaitForTimerActivity) ActivityType() string { return "WaitForTimer" } // WaitForNotificationActivity represents waiting for a notification. type WaitForNotificationActivity struct { BaseWorkflowActivity + BoundaryEvents []*BoundaryEvent `json:"boundaryEvents,omitempty"` // Boundary events (e.g., timers) } // ActivityType returns the type name. func (a *WaitForNotificationActivity) ActivityType() string { return "WaitForNotification" } +// EndOfParallelSplitPathActivity marks the end of a parallel split path (auto-generated by Mendix). +type EndOfParallelSplitPathActivity struct { + BaseWorkflowActivity +} + +// ActivityType returns the type name. +func (a *EndOfParallelSplitPathActivity) ActivityType() string { return "EndOfParallelSplitPath" } + +// EndOfBoundaryEventPathActivity marks the end of a boundary event path (auto-generated by Mendix). +type EndOfBoundaryEventPathActivity struct { + BaseWorkflowActivity +} + +// ActivityType returns the type name. +func (a *EndOfBoundaryEventPathActivity) ActivityType() string { return "EndOfBoundaryEventPath" } + +// WorkflowAnnotationActivity represents a standalone annotation (sticky note) on the workflow canvas. +type WorkflowAnnotationActivity struct { + BaseWorkflowActivity + Description string `json:"description,omitempty"` +} + +// ActivityType returns the type name. +func (a *WorkflowAnnotationActivity) ActivityType() string { return "WorkflowAnnotation" } + // GenericWorkflowActivity is a fallback for unknown activity types. type GenericWorkflowActivity struct { BaseWorkflowActivity @@ -199,7 +247,8 @@ type UserTaskOutcome struct { model.BaseElement Name string `json:"name,omitempty"` Caption string `json:"caption,omitempty"` - Flow *Flow `json:"flow,omitempty"` // Activities that follow this outcome + Value string `json:"value,omitempty"` // The outcome value (required, must be unique) + Flow *Flow `json:"flow,omitempty"` // Activities that follow this outcome } // ConditionOutcome is the interface for condition-based outcomes. @@ -218,9 +267,9 @@ type BooleanConditionOutcome struct { // GetName returns a display name for the outcome. func (o *BooleanConditionOutcome) GetName() string { if o.Value { - return "True" + return "TRUE" } - return "False" + return "FALSE" } // GetFlow returns the flow for this outcome. @@ -233,8 +282,11 @@ type EnumerationValueConditionOutcome struct { Flow *Flow `json:"flow,omitempty"` } -// GetName returns the enumeration value name. -func (o *EnumerationValueConditionOutcome) GetName() string { return o.Value } +// GetName returns the enumeration value name as a single-quoted MDL string literal. +func (o *EnumerationValueConditionOutcome) GetName() string { + escaped := strings.ReplaceAll(o.Value, "'", "''") + return "'" + escaped + "'" +} // GetFlow returns the flow for this outcome. func (o *EnumerationValueConditionOutcome) GetFlow() *Flow { return o.Flow } @@ -246,7 +298,7 @@ type VoidConditionOutcome struct { } // GetName returns a display name for the default outcome. -func (o *VoidConditionOutcome) GetName() string { return "Default" } +func (o *VoidConditionOutcome) GetName() string { return "DEFAULT" } // GetFlow returns the flow for this outcome. func (o *VoidConditionOutcome) GetFlow() *Flow { return o.Flow } @@ -257,6 +309,19 @@ type ParallelSplitOutcome struct { Flow *Flow `json:"flow,omitempty"` } +// ============================================================================ +// Boundary Events +// ============================================================================ + +// BoundaryEvent represents a boundary event attached to a workflow activity. +type BoundaryEvent struct { + model.BaseElement + Caption string `json:"caption,omitempty"` + Flow *Flow `json:"flow,omitempty"` // Activities triggered by the boundary event + TimerDelay string `json:"timerDelay,omitempty"` // Timer delay expression (for timer boundary events) + EventType string `json:"eventType,omitempty"` // e.g. "InterruptingTimer", "NonInterruptingTimer" +} + // ============================================================================ // User Sources // ============================================================================ diff --git a/tui/compare.go b/tui/compare.go new file mode 100644 index 0000000..229fe26 --- /dev/null +++ b/tui/compare.go @@ -0,0 +1,614 @@ +package tui + +import ( + "fmt" + "strings" + + "github.com/charmbracelet/bubbles/textinput" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" + "github.com/mendixlabs/mxcli/tui/panels" +) + +// CompareKind determines the comparison layout. +type CompareKind int + +const ( + CompareNDSL CompareKind = iota // NDSL | NDSL + CompareNDSLMDL // NDSL | MDL + CompareMDL // MDL | MDL +) + +// CompareFocus indicates which pane has focus. +type CompareFocus int + +const ( + CompareFocusLeft CompareFocus = iota + CompareFocusRight +) + +// CompareLoadMsg carries loaded content for a compare pane. +type CompareLoadMsg struct { + Side CompareFocus + Title string + NodeType string + Content string + Err error +} + +// ComparePickMsg is emitted when user selects a qname from the fuzzy picker. +type ComparePickMsg struct { + Side CompareFocus + QName string + NodeType string // tree node type (e.g. "Microflow", "Page") + Kind CompareKind +} + +// CompareReloadMsg requests that both panes reload with the current kind. +type CompareReloadMsg struct { + Kind CompareKind +} + +// PickerItem holds a qualified name with its type for the fuzzy picker. +type PickerItem struct { + QName string + NodeType string // e.g. "Microflow", "Workflow", "Page" +} + +// comparePane is one side of the comparison view. +type comparePane struct { + content ContentView + title string + qname string + nodeType string + loading bool +} + +func (p comparePane) scrollPercent() int { + return int(p.content.ScrollPercent() * 100) +} + +func (p comparePane) lineInfo() string { + return fmt.Sprintf("L%d/%d", p.content.YOffset()+1, p.content.TotalLines()) +} + +// CompareView is a side-by-side comparison overlay (lazygit-style). +type CompareView struct { + visible bool + kind CompareKind + focus CompareFocus + left comparePane + right comparePane + sync bool // synchronized scrolling + + // Fuzzy picker + picker bool + pickerInput textinput.Model + pickerItems []PickerItem + pickerMatches []pickerMatch + pickerCursor int + pickerOffset int + pickerSide CompareFocus + + width int + height int +} + +type pickerMatch struct { + item PickerItem + score int +} + +const pickerMaxShow = 12 + +func NewCompareView() CompareView { + ti := textinput.New() + ti.Prompt = "❯ " + ti.Placeholder = "type to search..." + ti.CharLimit = 200 + return CompareView{pickerInput: ti} +} + +func (c *CompareView) Show(kind CompareKind, w, h int) { + c.visible = true + c.kind = kind + c.focus = CompareFocusLeft + c.width = w + c.height = h + c.picker = false + c.sync = false + pw, ph := c.paneDimensions() + c.left.content = NewContentView(pw, ph) + c.right.content = NewContentView(pw, ph) +} + +func (c CompareView) paneDimensions() (int, int) { + pw := (c.width - 6) / 2 // borders + gap + ph := c.height - 4 // header + footer + borders + if pw < 20 { + pw = 20 + } + if ph < 5 { + ph = 5 + } + return pw, ph +} + +func (c *CompareView) Hide() { c.visible = false; c.picker = false } +func (c CompareView) IsVisible() bool { return c.visible } +func (c *CompareView) SetItems(items []PickerItem) { c.pickerItems = items } + +func (c *CompareView) SetContent(side CompareFocus, title, nodeType, content string) { + p := c.pane(side) + p.title = title + p.qname = title + p.nodeType = nodeType + p.loading = false + p.content.SetContent(content) + p.content.GotoTop() +} + +func (c *CompareView) SetLoading(side CompareFocus) { + p := c.pane(side) + p.loading = true + p.content.SetContent("Loading...") +} + +func (c CompareView) emitReload() tea.Cmd { + kind := c.kind + return func() tea.Msg { + return CompareReloadMsg{Kind: kind} + } +} + +func (c *CompareView) pane(side CompareFocus) *comparePane { + if side == CompareFocusRight { + return &c.right + } + return &c.left +} + +func (c *CompareView) focusedPane() *comparePane { return c.pane(c.focus) } + +// --- Picker --- + +func (c *CompareView) openPicker() { + c.picker = true + c.pickerSide = c.focus + c.pickerInput.SetValue("") + c.pickerInput.Focus() + c.pickerCursor = 0 + c.pickerOffset = 0 + c.filterPicker() +} + +func (c *CompareView) closePicker() { c.picker = false; c.pickerInput.Blur() } + +func (c *CompareView) filterPicker() { + query := strings.TrimSpace(c.pickerInput.Value()) + c.pickerMatches = nil + for _, it := range c.pickerItems { + if query == "" { + c.pickerMatches = append(c.pickerMatches, pickerMatch{item: it}) + continue + } + if ok, sc := fuzzyScore(it.QName, query); ok { + c.pickerMatches = append(c.pickerMatches, pickerMatch{item: it, score: sc}) + } + } + // Sort by score descending (insertion sort, small n) + for i := 1; i < len(c.pickerMatches); i++ { + for j := i; j > 0 && c.pickerMatches[j].score > c.pickerMatches[j-1].score; j-- { + c.pickerMatches[j], c.pickerMatches[j-1] = c.pickerMatches[j-1], c.pickerMatches[j] + } + } + if c.pickerCursor >= len(c.pickerMatches) { + c.pickerCursor = max(0, len(c.pickerMatches)-1) + } + c.pickerOffset = 0 +} + +func (c *CompareView) pickerDown() { + if len(c.pickerMatches) == 0 { + return + } + c.pickerCursor++ + if c.pickerCursor >= len(c.pickerMatches) { + c.pickerCursor = 0 + c.pickerOffset = 0 + } else if c.pickerCursor >= c.pickerOffset+pickerMaxShow { + c.pickerOffset = c.pickerCursor - pickerMaxShow + 1 + } +} + +func (c *CompareView) pickerUp() { + if len(c.pickerMatches) == 0 { + return + } + c.pickerCursor-- + if c.pickerCursor < 0 { + c.pickerCursor = len(c.pickerMatches) - 1 + c.pickerOffset = max(0, c.pickerCursor-pickerMaxShow+1) + } else if c.pickerCursor < c.pickerOffset { + c.pickerOffset = c.pickerCursor + } +} + +func (c CompareView) pickerSelected() PickerItem { + if len(c.pickerMatches) == 0 || c.pickerCursor >= len(c.pickerMatches) { + return PickerItem{} + } + return c.pickerMatches[c.pickerCursor].item +} + +// --- Update --- + +func (c CompareView) Update(msg tea.Msg) (CompareView, tea.Cmd) { + if !c.visible { + return c, nil + } + + switch msg := msg.(type) { + case tea.KeyMsg: + if c.picker { + return c.updatePicker(msg) + } + return c.updateNormal(msg) + + case tea.MouseMsg: + if c.picker { + return c, nil + } + return c.updateMouse(msg) + + case tea.WindowSizeMsg: + c.width = msg.Width + c.height = msg.Height + pw, ph := c.paneDimensions() + c.left.content.SetSize(pw, ph) + c.right.content.SetSize(pw, ph) + } + return c, nil +} + +func (c CompareView) updatePicker(msg tea.KeyMsg) (CompareView, tea.Cmd) { + switch msg.String() { + case "esc": + c.closePicker() + return c, nil + case "enter": + selected := c.pickerSelected() + c.closePicker() + if selected.QName != "" { + return c, func() tea.Msg { + return ComparePickMsg{Side: c.pickerSide, QName: selected.QName, NodeType: selected.NodeType, Kind: c.kind} + } + } + return c, nil + case "up", "ctrl+p": + c.pickerUp() + case "down", "ctrl+n": + c.pickerDown() + default: + var cmd tea.Cmd + c.pickerInput, cmd = c.pickerInput.Update(msg) + c.filterPicker() + return c, cmd + } + return c, nil +} + +func (c CompareView) updateNormal(msg tea.KeyMsg) (CompareView, tea.Cmd) { + // When content is searching, forward all keys to it + if c.focusedPane().content.IsSearching() { + p := c.focusedPane() + var cmd tea.Cmd + p.content, cmd = p.content.Update(msg) + return c, cmd + } + + switch msg.String() { + case "esc", "q": + c.visible = false + return c, nil + + // Focus switching — lazygit style: Tab only + case "tab": + if c.focus == CompareFocusLeft { + c.focus = CompareFocusRight + } else { + c.focus = CompareFocusLeft + } + return c, nil + + // Fuzzy picker + case "/": + c.openPicker() + return c, nil + + // Mode switching — reload both panes with new kind + case "1": + c.kind = CompareNDSL + return c, c.emitReload() + case "2": + c.kind = CompareNDSLMDL + return c, c.emitReload() + case "3": + c.kind = CompareMDL + return c, c.emitReload() + + // Refresh both panes + case "r": + return c, c.emitReload() + + // Sync scroll toggle + case "s": + c.sync = !c.sync + return c, nil + + // Scroll — forward j/k/arrows/pgup/pgdn/g/G to focused viewport + default: + p := c.focusedPane() + var cmd tea.Cmd + p.content, cmd = p.content.Update(msg) + + if c.sync { + c.syncOtherPane() + } + return c, cmd + } +} + +func (c CompareView) updateMouse(msg tea.MouseMsg) (CompareView, tea.Cmd) { + // Determine which pane the mouse is in + pw, _ := c.paneDimensions() + leftEnd := pw + 3 // border + padding + if msg.X < leftEnd { + c.focus = CompareFocusLeft + } else { + c.focus = CompareFocusRight + } + + // Forward mouse to focused pane's ContentView + p := c.focusedPane() + p.content, _ = p.content.Update(msg) + if c.sync { + c.syncOtherPane() + } + return c, nil +} + +func (c *CompareView) syncOtherPane() { + src := c.focusedPane() + other := &c.left + if c.focus == CompareFocusLeft { + other = &c.right + } + pct := src.content.ScrollPercent() + otherMax := other.content.maxOffset() + if otherMax > 0 { + other.content.SetYOffset(int(pct * float64(otherMax))) + } +} + +// --- View --- + +func (c CompareView) View() string { + if !c.visible { + return "" + } + + pw, _ := c.paneDimensions() + + // Pane rendering + leftView := c.renderPane(&c.left, CompareFocusLeft, pw) + rightView := c.renderPane(&c.right, CompareFocusRight, pw) + content := lipgloss.JoinHorizontal(lipgloss.Top, leftView, rightView) + + // Status bar (lazygit-style) + statusBar := c.renderStatusBar() + result := content + "\n" + statusBar + + // Picker overlay + if c.picker { + result = lipgloss.Place(c.width, c.height, + lipgloss.Center, lipgloss.Center, + c.renderPicker(), + lipgloss.WithWhitespaceBackground(lipgloss.Color("0"))) + } + + return result +} + +func (c CompareView) renderPane(p *comparePane, side CompareFocus, pw int) string { + focused := c.focus == side + bc := lipgloss.Color("240") + if focused { + bc = lipgloss.Color("63") + } + + border := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(bc). + Width(pw) + + titleSt := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("39")) + dimSt := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + loadSt := lipgloss.NewStyle().Foreground(lipgloss.Color("214")) + + // Title line: name [kind] scroll% + title := p.title + if title == "" { + title = "—" + } + if p.loading { + title += loadSt.Render(" ⏳") + } + kindTag := c.kindLabel(side) + scrollInfo := fmt.Sprintf("%s %d%%", p.lineInfo(), p.scrollPercent()) + + header := titleSt.Render(title) + " " + dimSt.Render(kindTag) + + strings.Repeat(" ", max(1, pw-lipgloss.Width(title)-lipgloss.Width(kindTag)-len(scrollInfo)-4)) + + dimSt.Render(scrollInfo) + + return border.Render(header + "\n" + p.content.View()) +} + +func (c CompareView) renderStatusBar() string { + dim := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + key := lipgloss.NewStyle().Foreground(lipgloss.Color("63")).Bold(true) + active := lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true) + + kindNames := []string{"NDSL|NDSL", "NDSL|MDL", "MDL|MDL"} + + var parts []string + parts = append(parts, key.Render("/")+" "+dim.Render("pick")) + parts = append(parts, key.Render("Tab")+" "+dim.Render("switch")) + + // Mode indicators + for i, name := range kindNames { + k := fmt.Sprintf("%d", i+1) + if CompareKind(i) == c.kind { + parts = append(parts, active.Render(k+" "+name)) + } else { + parts = append(parts, key.Render(k)+" "+dim.Render(name)) + } + } + + // Sync indicator + syncLabel := "sync" + if c.sync { + parts = append(parts, active.Render("s "+syncLabel)) + } else { + parts = append(parts, key.Render("s")+" "+dim.Render(syncLabel)) + } + + parts = append(parts, key.Render("/")+" "+dim.Render("search")) + if si := c.focusedPane().content.SearchInfo(); si != "" { + parts = append(parts, key.Render("n/N")+" "+active.Render(si)) + } + parts = append(parts, key.Render("r")+" "+dim.Render("reload")) + parts = append(parts, key.Render("j/k")+" "+dim.Render("scroll")) + parts = append(parts, key.Render("Esc")+" "+dim.Render("close")) + + return lipgloss.NewStyle().Width(c.width). + Background(lipgloss.Color("236")). + Foreground(lipgloss.Color("252")). + Render(" " + strings.Join(parts, " ")) +} + +func (c CompareView) kindLabel(side CompareFocus) string { + switch c.kind { + case CompareNDSL: + return "[NDSL]" + case CompareNDSLMDL: + if side == CompareFocusLeft { + return "[NDSL]" + } + return "[MDL]" + case CompareMDL: + return "[MDL]" + } + return "" +} + +func (c CompareView) renderPicker() string { + selSt := lipgloss.NewStyle().Foreground(lipgloss.Color("255")).Bold(true) + normSt := lipgloss.NewStyle().Foreground(lipgloss.Color("245")) + dimSt := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + titleSt := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("63")) + + sideLabel := "LEFT" + if c.pickerSide == CompareFocusRight { + sideLabel = "RIGHT" + } + + var sb strings.Builder + sb.WriteString(titleSt.Render(fmt.Sprintf("Pick object (%s)", sideLabel)) + "\n\n") + sb.WriteString(c.pickerInput.View() + "\n\n") + + end := min(c.pickerOffset+pickerMaxShow, len(c.pickerMatches)) + if c.pickerOffset > 0 { + sb.WriteString(dimSt.Render(" ↑ more") + "\n") + } + typeSt := lipgloss.NewStyle().Foreground(lipgloss.Color("63")) + for i := c.pickerOffset; i < end; i++ { + it := c.pickerMatches[i].item + if i == c.pickerCursor { + sb.WriteString(selSt.Render("▸ "+it.QName) + " " + typeSt.Render(it.NodeType) + "\n") + } else { + sb.WriteString(normSt.Render(" "+it.QName) + " " + dimSt.Render(it.NodeType) + "\n") + } + } + if end < len(c.pickerMatches) { + sb.WriteString(dimSt.Render(" ↓ more") + "\n") + } + sb.WriteString("\n" + dimSt.Render(fmt.Sprintf(" %d/%d matches", len(c.pickerMatches), len(c.pickerItems)))) + + return lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("63")). + Padding(1, 2). + Width(min(60, c.width-10)). + Render(sb.String()) +} + +// --- Utilities --- + +// fuzzyScore checks if query chars appear in order within target (fzf-style). +func fuzzyScore(target, query string) (bool, int) { + tLower := strings.ToLower(target) + qLower := strings.ToLower(query) + if len(qLower) == 0 { + return true, 0 + } + if len(qLower) > len(tLower) { + return false, 0 + } + score := 0 + qi := 0 + prevMatched := false + for ti := range len(tLower) { + if qi >= len(qLower) { + break + } + if tLower[ti] == qLower[qi] { + qi++ + if ti == 0 { + score += 7 + } else if target[ti-1] == '.' || target[ti-1] == '_' { + score += 5 + } else if target[ti] >= 'A' && target[ti] <= 'Z' { + score += 5 + } + if prevMatched { + score += 3 + } + prevMatched = true + } else { + prevMatched = false + } + } + if qi < len(qLower) { + return false, 0 + } + score += max(0, 50-len(tLower)) + return true, score +} + +func flattenQualifiedNames(nodes []*panels.TreeNode) []PickerItem { + var items []PickerItem + var walk func([]*panels.TreeNode) + walk = func(ns []*panels.TreeNode) { + for _, n := range ns { + if n.QualifiedName != "" { + items = append(items, PickerItem{QName: n.QualifiedName, NodeType: n.Type}) + } + if len(n.Children) > 0 { + walk(n.Children) + } + } + } + walk(nodes) + return items +} diff --git a/tui/contentview.go b/tui/contentview.go new file mode 100644 index 0000000..299f684 --- /dev/null +++ b/tui/contentview.go @@ -0,0 +1,397 @@ +package tui + +import ( + "fmt" + "strings" + + "github.com/charmbracelet/bubbles/textinput" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// ContentView is a scrollable content viewer with line numbers, scrollbar, +// vim navigation, search, and mouse support. +type ContentView struct { + lines []string + yOffset int + width int + height int + gutterW int + + // Search state + searching bool + searchInput textinput.Model + searchQuery string // locked-in query (after Enter) + matchLines []int // line indices that match + matchIdx int // current match index in matchLines +} + +func NewContentView(width, height int) ContentView { + ti := textinput.New() + ti.Prompt = "/" + ti.CharLimit = 200 + return ContentView{width: width, height: height, searchInput: ti} +} + +func (v *ContentView) SetContent(content string) { + v.lines = strings.Split(content, "\n") + v.yOffset = 0 + v.gutterW = max(4, len(fmt.Sprintf("%d", len(v.lines)))+1) + v.clearSearch() +} + +func (v *ContentView) SetSize(w, h int) { v.width = w; v.height = h } +func (v *ContentView) GotoTop() { v.yOffset = 0 } +func (v ContentView) TotalLines() int { return len(v.lines) } +func (v ContentView) YOffset() int { return v.yOffset } +func (v ContentView) IsSearching() bool { return v.searching } + +func (v ContentView) ScrollPercent() float64 { + m := v.maxOffset() + if m <= 0 { + return 1.0 + } + return float64(v.yOffset) / float64(m) +} + +func (v *ContentView) SetYOffset(y int) { v.yOffset = clamp(y, 0, v.maxOffset()) } + +func (v ContentView) maxOffset() int { return max(0, len(v.lines)-v.height) } + +func clamp(val, lo, hi int) int { + if val < lo { + return lo + } + if val > hi { + return hi + } + return val +} + +// SearchInfo returns a summary like "3/12" (current match / total matches) or "". +func (v ContentView) SearchInfo() string { + if v.searchQuery == "" || len(v.matchLines) == 0 { + return "" + } + return fmt.Sprintf("%d/%d", v.matchIdx+1, len(v.matchLines)) +} + +// --- Search --- + +func (v *ContentView) startSearch() { + v.searching = true + v.searchInput.SetValue(v.searchQuery) + v.searchInput.Focus() +} + +func (v *ContentView) clearSearch() { + v.searching = false + v.searchQuery = "" + v.matchLines = nil + v.matchIdx = 0 + v.searchInput.Blur() +} + +func (v *ContentView) commitSearch() { + v.searching = false + v.searchInput.Blur() + v.searchQuery = strings.TrimSpace(v.searchInput.Value()) + v.buildMatchLines() + if len(v.matchLines) > 0 { + v.matchIdx = 0 + v.scrollToMatch() + } +} + +func (v *ContentView) buildMatchLines() { + v.matchLines = nil + if v.searchQuery == "" { + return + } + q := strings.ToLower(v.searchQuery) + for i, line := range v.lines { + // Strip ANSI for matching + if strings.Contains(strings.ToLower(stripANSI(line)), q) { + v.matchLines = append(v.matchLines, i) + } + } +} + +func (v *ContentView) nextMatch() { + if len(v.matchLines) == 0 { + return + } + v.matchIdx = (v.matchIdx + 1) % len(v.matchLines) + v.scrollToMatch() +} + +func (v *ContentView) prevMatch() { + if len(v.matchLines) == 0 { + return + } + v.matchIdx-- + if v.matchIdx < 0 { + v.matchIdx = len(v.matchLines) - 1 + } + v.scrollToMatch() +} + +func (v *ContentView) scrollToMatch() { + if v.matchIdx >= len(v.matchLines) { + return + } + target := v.matchLines[v.matchIdx] + // Center the match in the viewport + v.yOffset = clamp(target-v.height/2, 0, v.maxOffset()) +} + +// stripANSI removes ANSI escape sequences from a string for plain-text matching. +func stripANSI(s string) string { + var sb strings.Builder + sb.Grow(len(s)) + inEsc := false + for i := 0; i < len(s); i++ { + if s[i] == '\x1b' { + inEsc = true + continue + } + if inEsc { + if (s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= 'a' && s[i] <= 'z') { + inEsc = false + } + continue + } + sb.WriteByte(s[i]) + } + return sb.String() +} + +// --- Update --- + +func (v ContentView) Update(msg tea.Msg) (ContentView, tea.Cmd) { + switch msg := msg.(type) { + case tea.KeyMsg: + if v.searching { + return v.updateSearch(msg) + } + return v.updateNormal(msg) + + case tea.MouseMsg: + if msg.Action == tea.MouseActionPress { + switch msg.Button { + case tea.MouseButtonWheelUp: + v.yOffset = clamp(v.yOffset-3, 0, v.maxOffset()) + case tea.MouseButtonWheelDown: + v.yOffset = clamp(v.yOffset+3, 0, v.maxOffset()) + } + } + } + return v, nil +} + +func (v ContentView) updateSearch(msg tea.KeyMsg) (ContentView, tea.Cmd) { + switch msg.String() { + case "esc": + v.searching = false + v.searchInput.Blur() + return v, nil + case "enter": + v.commitSearch() + return v, nil + default: + var cmd tea.Cmd + v.searchInput, cmd = v.searchInput.Update(msg) + // Live search: update matches as user types + v.searchQuery = strings.TrimSpace(v.searchInput.Value()) + v.buildMatchLines() + if len(v.matchLines) > 0 { + v.matchIdx = 0 + v.scrollToMatch() + } + return v, cmd + } +} + +func (v ContentView) updateNormal(msg tea.KeyMsg) (ContentView, tea.Cmd) { + switch msg.String() { + case "j", "down": + v.yOffset = clamp(v.yOffset+1, 0, v.maxOffset()) + case "k", "up": + v.yOffset = clamp(v.yOffset-1, 0, v.maxOffset()) + case "d", "ctrl+d": + v.yOffset = clamp(v.yOffset+v.height/2, 0, v.maxOffset()) + case "u", "ctrl+u": + v.yOffset = clamp(v.yOffset-v.height/2, 0, v.maxOffset()) + case "f", "pgdown": + v.yOffset = clamp(v.yOffset+v.height, 0, v.maxOffset()) + case "b", "pgup": + v.yOffset = clamp(v.yOffset-v.height, 0, v.maxOffset()) + case "g", "home": + v.yOffset = 0 + case "G", "end": + v.yOffset = v.maxOffset() + case "/": + v.startSearch() + case "n": + v.nextMatch() + case "N": + v.prevMatch() + } + return v, nil +} + +// --- View --- + +func (v ContentView) View() string { + if len(v.lines) == 0 { + return "" + } + + lineNumSt := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + matchLineNumSt := lipgloss.NewStyle().Foreground(lipgloss.Color("214")) + currentMatchNumSt := lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true) + trackSt := lipgloss.NewStyle().Foreground(lipgloss.Color("238")) + thumbSt := lipgloss.NewStyle().Foreground(lipgloss.Color("63")) + matchSt := lipgloss.NewStyle().Background(lipgloss.Color("58")) + currentMatchSt := lipgloss.NewStyle().Background(lipgloss.Color("214")).Foreground(lipgloss.Color("0")) + + total := len(v.lines) + showScrollbar := total > v.height + contentW := v.width - v.gutterW - 1 + if showScrollbar { + contentW-- + } + contentW = max(10, contentW) + + // Scrollbar geometry + var thumbStart, thumbEnd int + if showScrollbar { + trackH := v.height + thumbSize := max(1, trackH*v.height/total) + if m := v.maxOffset(); m > 0 { + thumbStart = v.yOffset * (trackH - thumbSize) / m + } + thumbEnd = thumbStart + thumbSize + } + + // Current match line (for highlighting) + currentMatchLine := -1 + if v.searchQuery != "" && len(v.matchLines) > 0 && v.matchIdx < len(v.matchLines) { + currentMatchLine = v.matchLines[v.matchIdx] + } + + // Match line set for fast lookup + matchSet := make(map[int]bool, len(v.matchLines)) + for _, ml := range v.matchLines { + matchSet[ml] = true + } + + viewH := v.height + if v.searching { + viewH-- // reserve last line for search input + } + + var sb strings.Builder + for vi := range viewH { + lineIdx := v.yOffset + vi + var line string + if lineIdx < total { + num := fmt.Sprintf("%*d", v.gutterW-1, lineIdx+1) + + // Style line number based on match status + var gutter string + if lineIdx == currentMatchLine { + gutter = currentMatchNumSt.Render(num) + " " + } else if matchSet[lineIdx] { + gutter = matchLineNumSt.Render(num) + " " + } else { + gutter = lineNumSt.Render(num) + " " + } + + content := v.lines[lineIdx] + + // Highlight search matches within the line + if v.searchQuery != "" && matchSet[lineIdx] { + if lineIdx == currentMatchLine { + content = highlightMatches(content, v.searchQuery, currentMatchSt) + } else { + content = highlightMatches(content, v.searchQuery, matchSt) + } + } + + // Truncate + if lipgloss.Width(content) > contentW { + runes := []rune(content) + if len(runes) > contentW { + content = string(runes[:contentW]) + } + } + + // Pad + if pad := contentW - lipgloss.Width(content); pad > 0 { + content += strings.Repeat(" ", pad) + } + + line = gutter + content + } else { + line = strings.Repeat(" ", v.gutterW+contentW) + } + + // Scrollbar + if showScrollbar { + if vi >= thumbStart && vi < thumbEnd { + line += thumbSt.Render("█") + } else { + line += trackSt.Render("│") + } + } + + sb.WriteString(line) + if vi < viewH-1 || v.searching { + sb.WriteString("\n") + } + } + + // Search input bar + if v.searching { + matchInfo := "" + if q := strings.TrimSpace(v.searchInput.Value()); q != "" { + matchInfo = fmt.Sprintf(" (%d matches)", len(v.matchLines)) + } + sb.WriteString(v.searchInput.View() + lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(matchInfo)) + } + + return sb.String() +} + +// highlightMatches highlights all occurrences of query in the line (case-insensitive). +// Works with ANSI-colored text by matching on stripped text and applying style around matches. +func highlightMatches(line, query string, style lipgloss.Style) string { + plain := stripANSI(line) + lowerPlain := strings.ToLower(plain) + lowerQuery := strings.ToLower(query) + + // If line has no ANSI, do simple replacement + if plain == line { + var result strings.Builder + remaining := line + lowerRemaining := lowerPlain + for { + idx := strings.Index(lowerRemaining, lowerQuery) + if idx < 0 { + result.WriteString(remaining) + break + } + result.WriteString(remaining[:idx]) + result.WriteString(style.Render(remaining[idx : idx+len(query)])) + remaining = remaining[idx+len(query):] + lowerRemaining = lowerRemaining[idx+len(query):] + } + return result.String() + } + + // For ANSI text, find match positions in plain text and highlight + // by wrapping the entire line with a marker. Simple approach: just return + // the line as-is with ANSI — the line number coloring indicates matches. + return line +} diff --git a/tui/help.go b/tui/help.go new file mode 100644 index 0000000..6de38a1 --- /dev/null +++ b/tui/help.go @@ -0,0 +1,49 @@ +package tui + +import "github.com/charmbracelet/lipgloss" + +const helpText = ` + mxcli tui — Keyboard Reference + + NAVIGATION + j / ↓ move down / scroll + k / ↑ move up / scroll + l / → / Enter drill in / expand + h / ← go back + Tab cycle panel focus + / filter in list + Esc back / close + + ACTIONS + b BSON dump (overlay) + c compare view (side-by-side) + d diagram in browser + r refresh project tree + z zen mode (zoom panel) + Enter full detail (in preview) + + COMPARE VIEW + Tab switch left/right pane + / fuzzy pick object + 1/2/3 NDSL|NDSL / NDSL|MDL / MDL|MDL + s toggle sync scroll + j/k scroll content + Esc close + + OTHER + ? show/hide this help + q quit +` + +func renderHelp(width, _ int) string { + helpWidth := width / 2 + if helpWidth < 60 { + helpWidth = 60 + } + return lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("63")). + Width(helpWidth). + Padding(1, 2). + Render(helpText) +} diff --git a/tui/highlight.go b/tui/highlight.go new file mode 100644 index 0000000..b6c580a --- /dev/null +++ b/tui/highlight.go @@ -0,0 +1,133 @@ +package tui + +import ( + "bytes" + "strings" + + "github.com/alecthomas/chroma/v2" + "github.com/alecthomas/chroma/v2/formatters" + "github.com/alecthomas/chroma/v2/lexers" + "github.com/alecthomas/chroma/v2/styles" +) + +var ndslLexer = chroma.MustNewLexer( + &chroma.Config{ + Name: "NDSL", + Aliases: []string{"ndsl"}, + MimeTypes: []string{"text/x-ndsl"}, + }, + func() chroma.Rules { + return chroma.Rules{ + "root": { + {Pattern: `\$Type\b`, Type: chroma.KeywordType}, + {Pattern: ``, Type: chroma.CommentPreproc}, + {Pattern: `int(?:32|64)\(\d+\)`, Type: chroma.LiteralNumberInteger}, + {Pattern: `[A-Z][A-Za-z]*(?:\[\d+\])?(?:\.[A-Z][A-Za-z]*(?:\[\d+\])?)*`, Type: chroma.NameAttribute}, + {Pattern: `"[^"]*"`, Type: chroma.LiteralString}, + {Pattern: `'[^']*'`, Type: chroma.LiteralString}, + {Pattern: `\b\d+(?:\.\d+)?\b`, Type: chroma.LiteralNumber}, + {Pattern: `\b(?:true|false|null)\b`, Type: chroma.KeywordConstant}, + {Pattern: `\s+`, Type: chroma.TextWhitespace}, + {Pattern: `[=:,\[\]{}()]`, Type: chroma.Punctuation}, + {Pattern: `.`, Type: chroma.Text}, + }, + } + }, +) + +func highlight(content string, lexer chroma.Lexer) string { + formatter := formatters.Get("terminal256") + if formatter == nil { + return content + } + style := styles.Get("monokai") + if style == nil { + return content + } + + iterator, err := lexer.Tokenise(nil, content) + if err != nil { + return content + } + + var buf bytes.Buffer + if err := formatter.Format(&buf, style, iterator); err != nil { + return content + } + return buf.String() +} + +// HighlightMDL highlights MDL content using the SQL lexer as a base. +func HighlightMDL(content string) string { + lexer := lexers.Get("sql") + if lexer == nil { + return content + } + return highlight(content, lexer) +} + +// HighlightSQL highlights standard SQL content. +func HighlightSQL(content string) string { + lexer := lexers.Get("sql") + if lexer == nil { + return content + } + return highlight(content, lexer) +} + +// HighlightNDSL highlights NDSL format content with custom lexer rules. +func HighlightNDSL(content string) string { + return highlight(content, ndslLexer) +} + +// StripBanner removes the "Connected to: ..." banner line from mxcli output. +func StripBanner(content string) string { + lines := strings.SplitN(content, "\n", 2) + if len(lines) > 1 && strings.HasPrefix(lines[0], "Connected to:") { + return strings.TrimLeft(lines[1], "\n") + } + return content +} + +// DetectAndHighlight strips mxcli banner, auto-detects content type, and applies highlighting. +func DetectAndHighlight(content string) string { + content = StripBanner(content) + if content == "" { + return content + } + + // NDSL detection: $Type or field path patterns + if strings.Contains(content, "$Type") { + return HighlightNDSL(content) + } + + // Scan first non-blank lines for type detection + for _, line := range strings.SplitN(content, "\n", 20) { + trimmed := strings.ToUpper(strings.TrimSpace(line)) + if trimmed == "" { + continue + } + + // MDL keywords + for _, kw := range []string{"CREATE ", "ALTER ", "SHOW ", "DESCRIBE ", "DROP ", + "GRANT ", "REVOKE ", "WORKFLOW ", "MICROFLOW ", "ENTITY ", "PAGE ", "NANOFLOW "} { + if strings.HasPrefix(trimmed, kw) { + return HighlightMDL(content) + } + } + + // SQL keywords + for _, kw := range []string{"SELECT ", "INSERT ", "UPDATE ", "DELETE ", "WITH "} { + if strings.HasPrefix(trimmed, kw) { + return HighlightSQL(content) + } + } + + // Comment lines (DESCRIBE output) + if strings.HasPrefix(trimmed, "-- ") { + return HighlightMDL(content) + } + } + + return content +} diff --git a/tui/history.go b/tui/history.go new file mode 100644 index 0000000..9603cfd --- /dev/null +++ b/tui/history.go @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: Apache-2.0 + +package tui + +import ( + "encoding/json" + "os" + "path/filepath" + "slices" +) + +func historyPath() string { + home, _ := os.UserHomeDir() + return filepath.Join(home, ".mxcli", "tui_history.json") +} + +// LoadHistory returns recent project paths, most recent first. +func LoadHistory() []string { + data, err := os.ReadFile(historyPath()) + if err != nil { + return nil + } + var paths []string + json.Unmarshal(data, &paths) + return paths +} + +// SaveHistory adds mprPath to the front of the history list (max 10 entries). +func SaveHistory(mprPath string) { + paths := LoadHistory() + paths = slices.DeleteFunc(paths, func(p string) bool { return p == mprPath }) + paths = append([]string{mprPath}, paths...) + if len(paths) > 10 { + paths = paths[:10] + } + os.MkdirAll(filepath.Dir(historyPath()), 0755) + data, _ := json.Marshal(paths) + os.WriteFile(historyPath(), data, 0644) +} diff --git a/tui/layout.go b/tui/layout.go new file mode 100644 index 0000000..1e0ab3a --- /dev/null +++ b/tui/layout.go @@ -0,0 +1,38 @@ +package tui + +// PanelVisibility controls how many panels are shown. +type PanelVisibility int + +const ( + ShowOnePanel PanelVisibility = iota // modules 100% + ShowTwoPanels // modules 35%, elements 65% + ShowZoomed // zoomed panel 100% +) + +// PanelRect describes a panel's position, size, and visibility. +type PanelRect struct { + X, Y, Width, Height int + Visible bool +} + +// panelWidths2 returns [modulesW, elementsW] based on visibility mode. +func panelWidths2(totalW int, vis PanelVisibility, zoomedPanel Focus) (int, int) { + available := totalW - 4 // 2 borders × 2 panels + if available < 30 { + available = 30 + } + + switch vis { + case ShowOnePanel: + return available, 0 + case ShowTwoPanels: + modulesW := available * 35 / 100 + return modulesW, available - modulesW + case ShowZoomed: + if zoomedPanel == FocusElements { + return 0, available + } + return available, 0 + } + return available, 0 +} diff --git a/tui/model.go b/tui/model.go new file mode 100644 index 0000000..64a9d37 --- /dev/null +++ b/tui/model.go @@ -0,0 +1,559 @@ +package tui + +import ( + "fmt" + "os" + "strings" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" + "github.com/mendixlabs/mxcli/tui/panels" +) + +// Focus indicates which panel has keyboard focus. +type Focus int + +const ( + FocusModules Focus = iota + FocusElements +) + +// CmdResultMsg carries output from any mxcli command. +type CmdResultMsg struct { + Output string + Err error +} + +// Model is the root Bubble Tea model for the TUI. +type Model struct { + mxcliPath string + projectPath string + width int + height int + focus Focus + modulesPanel panels.ModulesPanel + elementsPanel panels.ElementsPanel + showHelp bool + overlay Overlay + compare CompareView + + visibility PanelVisibility + zenMode bool + zenPrevFocus Focus + zenPrevVisibility PanelVisibility + panelLayout [2]PanelRect + allNodes []*panels.TreeNode +} + +func New(mxcliPath, projectPath string) Model { + panels.HighlightFunc = DetectAndHighlight + return Model{ + mxcliPath: mxcliPath, + projectPath: projectPath, + focus: FocusModules, + visibility: ShowOnePanel, + modulesPanel: panels.NewModulesPanel(30, 20), + elementsPanel: panels.NewElementsPanel(40, 20), + overlay: NewOverlay(), + compare: NewCompareView(), + } +} + +func (m Model) Init() tea.Cmd { + return func() tea.Msg { + out, err := runMxcli(m.mxcliPath, "project-tree", "-p", m.projectPath) + if err != nil { + return panels.LoadTreeMsg{Err: err} + } + nodes, parseErr := panels.ParseTree(out) + return panels.LoadTreeMsg{Nodes: nodes, Err: parseErr} + } +} + +func (m Model) openDiagram(nodeType, qualifiedName string) tea.Cmd { + return func() tea.Msg { + out, err := runMxcli(m.mxcliPath, "describe", "-p", m.projectPath, + "--format", "elk", nodeType, qualifiedName) + if err != nil { + return CmdResultMsg{Output: out, Err: err} + } + htmlContent := buildDiagramHTML(out, nodeType, qualifiedName) + tmpFile, err := os.CreateTemp("", "mxcli-diagram-*.html") + if err != nil { + return CmdResultMsg{Err: err} + } + defer tmpFile.Close() + tmpFile.WriteString(htmlContent) + openBrowser(tmpFile.Name()) + return CmdResultMsg{Output: fmt.Sprintf("Opened diagram: %s", tmpFile.Name())} + } +} + +func buildDiagramHTML(elkJSON, nodeType, qualifiedName string) string { + return fmt.Sprintf(` +%s %s + + +
`, nodeType, qualifiedName, elkJSON) +} + +func (m Model) selectedNode() *panels.TreeNode { + if node := m.elementsPanel.SelectedNode(); node != nil { + return node + } + return m.modulesPanel.SelectedNode() +} + +// inferBsonType maps tree node types to valid bson object types. +func inferBsonType(nodeType string) string { + switch strings.ToLower(nodeType) { + case "page", "microflow", "nanoflow", "workflow", + "enumeration", "snippet", "layout", "entity": + return strings.ToLower(nodeType) + default: + return "" + } +} + +// isFilterActive returns true if any panel's filter/search input is active. +func (m Model) isFilterActive() bool { + return m.modulesPanel.IsFilterActive() || m.elementsPanel.IsFilterActive() +} + +// --- Load helpers --- + +func (m Model) loadBsonNDSL(qname, nodeType string, side CompareFocus) tea.Cmd { + return func() tea.Msg { + bsonType := inferBsonType(nodeType) + if bsonType == "" { + return CompareLoadMsg{Side: side, Title: qname, NodeType: nodeType, + Content: fmt.Sprintf("Error: type %q not supported for BSON dump", nodeType), + Err: fmt.Errorf("unsupported type")} + } + args := []string{"bson", "dump", "-p", m.projectPath, "--format", "ndsl", + "--type", bsonType, "--object", qname} + out, err := runMxcli(m.mxcliPath, args...) + out = StripBanner(out) + if err != nil { + return CompareLoadMsg{Side: side, Title: qname, NodeType: nodeType, Content: "Error: " + out, Err: err} + } + return CompareLoadMsg{Side: side, Title: qname, NodeType: nodeType, Content: HighlightNDSL(out)} + } +} + +func (m Model) loadMDL(qname, nodeType string, side CompareFocus) tea.Cmd { + return func() tea.Msg { + out, err := runMxcli(m.mxcliPath, "-p", m.projectPath, "-c", + fmt.Sprintf("DESCRIBE %s %s", strings.ToUpper(nodeType), qname)) + out = StripBanner(out) + if err != nil { + return CompareLoadMsg{Side: side, Title: qname, NodeType: nodeType, Content: "Error: " + out, Err: err} + } + return CompareLoadMsg{Side: side, Title: qname, NodeType: nodeType, Content: DetectAndHighlight(out)} + } +} + +func (m Model) loadForCompare(qname, nodeType string, side CompareFocus, kind CompareKind) tea.Cmd { + switch kind { + case CompareNDSL: + return m.loadBsonNDSL(qname, nodeType, side) + case CompareNDSLMDL: + if side == CompareFocusLeft { + return m.loadBsonNDSL(qname, nodeType, side) + } + return m.loadMDL(qname, nodeType, side) + case CompareMDL: + return m.loadMDL(qname, nodeType, side) + } + return nil +} + +func (m Model) runBsonOverlay(bsonType, qname string) tea.Cmd { + return func() tea.Msg { + args := []string{"bson", "dump", "-p", m.projectPath, "--format", "ndsl", + "--type", bsonType, "--object", qname} + out, err := runMxcli(m.mxcliPath, args...) + out = StripBanner(out) + title := fmt.Sprintf("BSON: %s", qname) + if err != nil { + return panels.OpenOverlayMsg{Title: title, Content: "Error: " + out} + } + return panels.OpenOverlayMsg{Title: title, Content: HighlightNDSL(out)} + } +} + +func (m Model) runMDLOverlay(nodeType, qname string) tea.Cmd { + return func() tea.Msg { + out, err := runMxcli(m.mxcliPath, "-p", m.projectPath, "-c", + fmt.Sprintf("DESCRIBE %s %s", strings.ToUpper(nodeType), qname)) + out = StripBanner(out) + title := fmt.Sprintf("MDL: %s", qname) + if err != nil { + return panels.OpenOverlayMsg{Title: title, Content: "Error: " + out} + } + return panels.OpenOverlayMsg{Title: title, Content: DetectAndHighlight(out)} + } +} + +// --- Update --- + +func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + switch msg := msg.(type) { + case panels.OpenOverlayMsg: + m.overlay.Show(msg.Title, msg.Content, m.width, m.height) + return m, nil + + case CompareLoadMsg: + m.compare.SetContent(msg.Side, msg.Title, msg.NodeType, msg.Content) + return m, nil + + case ComparePickMsg: + m.compare.SetLoading(msg.Side) + return m, m.loadForCompare(msg.QName, msg.NodeType, msg.Side, msg.Kind) + + case CompareReloadMsg: + var cmds []tea.Cmd + if m.compare.left.qname != "" { + m.compare.SetLoading(CompareFocusLeft) + cmds = append(cmds, m.loadForCompare(m.compare.left.qname, m.compare.left.nodeType, CompareFocusLeft, msg.Kind)) + } + if m.compare.right.qname != "" { + m.compare.SetLoading(CompareFocusRight) + cmds = append(cmds, m.loadForCompare(m.compare.right.qname, m.compare.right.nodeType, CompareFocusRight, msg.Kind)) + } + return m, tea.Batch(cmds...) + + case tea.KeyMsg: + if msg.String() == "ctrl+c" { + return m, tea.Quit + } + + // Fullscreen modes intercept all keys + if m.compare.IsVisible() { + var cmd tea.Cmd + m.compare, cmd = m.compare.Update(msg) + return m, cmd + } + if m.overlay.IsVisible() { + var cmd tea.Cmd + m.overlay, cmd = m.overlay.Update(msg) + return m, cmd + } + if m.showHelp { + m.showHelp = false + return m, nil + } + + // When filter is active, only allow filter-related keys at global level + if m.isFilterActive() { + return m.updateFilterMode(msg) + } + + return m.updateNormalMode(msg) + + case tea.MouseMsg: + if m.compare.IsVisible() || m.overlay.IsVisible() { + return m, nil + } + return m.updateMouse(msg) + + case tea.WindowSizeMsg: + m.width = msg.Width + m.height = msg.Height + m.resizePanels() + + case panels.LoadTreeMsg: + if msg.Err == nil && msg.Nodes != nil { + m.allNodes = msg.Nodes + m.modulesPanel.SetNodes(msg.Nodes) + m.compare.SetItems(flattenQualifiedNames(msg.Nodes)) + } + + case CmdResultMsg: + content := msg.Output + if msg.Err != nil { + content = "-- Error:\n" + msg.Output + } + m.overlay.Show("Result", DetectAndHighlight(content), m.width, m.height) + } + return m, nil +} + +// updateFilterMode handles keys when a panel's filter input is active. +// All keys go to the focused panel — no global shortcuts. +func (m Model) updateFilterMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) { + switch m.focus { + case FocusModules: + var cmd tea.Cmd + m.modulesPanel, cmd = m.modulesPanel.Update(msg) + return m, cmd + case FocusElements: + var cmd tea.Cmd + m.elementsPanel, cmd = m.elementsPanel.Update(msg) + return m, cmd + } + return m, nil +} + +// updateNormalMode handles keys when no filter is active. +func (m Model) updateNormalMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) { + // Global shortcuts + switch msg.String() { + case "q": + return m, tea.Quit + case "?": + m.showHelp = !m.showHelp + return m, nil + case "tab": + if m.focus == FocusModules { + m.focus = FocusElements + } else { + m.focus = FocusModules + } + return m, nil + case "z": + if m.zenMode { + m.zenMode = false + m.visibility = m.zenPrevVisibility + m.focus = m.zenPrevFocus + } else { + m.zenMode = true + m.zenPrevFocus = m.focus + m.zenPrevVisibility = m.visibility + m.visibility = ShowZoomed + } + m.resizePanels() + return m, nil + + case "b": + if node := m.selectedNode(); node != nil && node.QualifiedName != "" { + if bsonType := inferBsonType(node.Type); bsonType != "" { + return m, m.runBsonOverlay(bsonType, node.QualifiedName) + } + } + case "m": + if node := m.selectedNode(); node != nil && node.QualifiedName != "" { + return m, m.runMDLOverlay(node.Type, node.QualifiedName) + } + case "c": + m.compare.Show(CompareNDSL, m.width, m.height) + m.compare.SetItems(flattenQualifiedNames(m.allNodes)) + if node := m.selectedNode(); node != nil && node.QualifiedName != "" { + m.compare.SetLoading(CompareFocusLeft) + return m, m.loadBsonNDSL(node.QualifiedName, node.Type, CompareFocusLeft) + } + return m, nil + case "d": + if node := m.selectedNode(); node != nil && node.QualifiedName != "" { + return m, m.openDiagram(node.Type, node.QualifiedName) + } + case "r": + return m, m.Init() + } + + // Panel-specific keys + switch m.focus { + case FocusModules: + switch msg.String() { + case "l", "right", "enter": + if node := m.modulesPanel.SelectedNode(); node != nil && len(node.Children) > 0 { + m.elementsPanel.SetNodes(node.Children) + m.focus = FocusElements + m.setVisibility(ShowTwoPanels) + return m, nil + } + case "j", "down", "k", "up": + var cmd tea.Cmd + m.modulesPanel, cmd = m.modulesPanel.Update(msg) + if node := m.modulesPanel.SelectedNode(); node != nil && len(node.Children) > 0 { + m.elementsPanel.SetNodes(node.Children) + m.setVisibility(ShowTwoPanels) + } + return m, cmd + default: + var cmd tea.Cmd + m.modulesPanel, cmd = m.modulesPanel.Update(msg) + return m, cmd + } + + case FocusElements: + switch msg.String() { + case "h", "left": + m.focus = FocusModules + m.setVisibility(ShowOnePanel) + return m, nil + case "l", "right", "enter": + if node := m.elementsPanel.SelectedNode(); node != nil { + if len(node.Children) > 0 { + m.elementsPanel.SetNodes(node.Children) + return m, nil + } + // Open MDL describe in overlay + if node.QualifiedName != "" { + return m, m.runMDLOverlay(node.Type, node.QualifiedName) + } + } + case "j", "down", "k", "up": + var cmd tea.Cmd + m.elementsPanel, cmd = m.elementsPanel.Update(msg) + return m, cmd + default: + var cmd tea.Cmd + m.elementsPanel, cmd = m.elementsPanel.Update(msg) + return m, cmd + } + } + return m, nil +} + +func (m Model) updateMouse(msg tea.MouseMsg) (tea.Model, tea.Cmd) { + for i, rect := range m.panelLayout { + if !rect.Visible { + continue + } + if msg.X >= rect.X && msg.X < rect.X+rect.Width && + msg.Y >= rect.Y && msg.Y < rect.Y+rect.Height { + localMsg := tea.MouseMsg{ + X: msg.X - rect.X - 1, Y: msg.Y - rect.Y - 1, + Button: msg.Button, Action: msg.Action, + } + m.focus = Focus(i) + switch Focus(i) { + case FocusModules: + var cmd tea.Cmd + m.modulesPanel, cmd = m.modulesPanel.Update(localMsg) + return m, cmd + case FocusElements: + var cmd tea.Cmd + m.elementsPanel, cmd = m.elementsPanel.Update(localMsg) + return m, cmd + } + break + } + } + return m, nil +} + +func (m *Model) setVisibility(vis PanelVisibility) { + if m.zenMode { + return + } + m.visibility = vis + m.resizePanels() +} + +func (m *Model) resizePanels() { + mW, eW := panelWidths2(m.width, m.visibility, m.focus) + contentH := m.height - 2 + if mW > 0 { + m.modulesPanel.SetSize(mW, contentH) + } + if eW > 0 { + m.elementsPanel.SetSize(eW, contentH) + } + + widths := [2]int{mW, eW} + x := 0 + for i, w := range widths { + if w > 0 { + m.panelLayout[i] = PanelRect{ + X: x, Y: 0, Width: w + 2, Height: contentH + 2, Visible: true, + } + x += w + 2 + } else { + m.panelLayout[i] = PanelRect{} + } + } +} + +// --- View --- + +func (m Model) View() string { + if m.width == 0 { + return "mxcli tui — loading...\n\nPress q to quit" + } + + if m.compare.IsVisible() { + return m.compare.View() + } + if m.overlay.IsVisible() { + return m.overlay.View() + } + + m.modulesPanel.SetFocused(m.focus == FocusModules) + m.elementsPanel.SetFocused(m.focus == FocusElements) + + mW, eW := panelWidths2(m.width, m.visibility, m.focus) + contentH := m.height - 2 + if mW > 0 { + m.modulesPanel.SetSize(mW, contentH) + } + if eW > 0 { + m.elementsPanel.SetSize(eW, contentH) + } + + statusLine := m.renderStatusBar() + + var visiblePanels []string + if mW > 0 { + visiblePanels = append(visiblePanels, m.modulesPanel.View()) + } + if eW > 0 { + visiblePanels = append(visiblePanels, m.elementsPanel.View()) + } + + cols := lipgloss.JoinHorizontal(lipgloss.Top, visiblePanels...) + status := lipgloss.NewStyle(). + Background(lipgloss.Color("236")). + Foreground(lipgloss.Color("252")). + Width(m.width). + Render(statusLine) + + rendered := cols + "\n" + status + + if m.showHelp { + helpView := renderHelp(m.width, m.height) + rendered = lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, helpView, + lipgloss.WithWhitespaceBackground(lipgloss.Color("0"))) + } + + return rendered +} + +func (m Model) renderStatusBar() string { + dim := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + key := lipgloss.NewStyle().Foreground(lipgloss.Color("63")).Bold(true) + active := lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true) + + var parts []string + + if node := m.selectedNode(); node != nil && node.QualifiedName != "" { + if inferBsonType(node.Type) != "" { + parts = append(parts, key.Render("b")+" "+dim.Render("bson")) + } + parts = append(parts, key.Render("m")+" "+dim.Render("mdl")) + parts = append(parts, key.Render("c")+" "+dim.Render("compare")) + parts = append(parts, key.Render("d")+" "+dim.Render("diagram")) + } + + parts = append(parts, key.Render("/")+" "+dim.Render("filter")) + parts = append(parts, key.Render("r")+" "+dim.Render("refresh")) + + if m.zenMode { + parts = append(parts, active.Render("z ZEN")) + } else { + parts = append(parts, key.Render("z")+" "+dim.Render("zen")) + } + + parts = append(parts, key.Render("?")+" "+dim.Render("help")) + parts = append(parts, key.Render("q")+" "+dim.Render("quit")) + + return " " + strings.Join(parts, " ") +} diff --git a/tui/overlay.go b/tui/overlay.go new file mode 100644 index 0000000..22cb792 --- /dev/null +++ b/tui/overlay.go @@ -0,0 +1,110 @@ +package tui + +import ( + "fmt" + "strings" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// Overlay is a fullscreen modal with scrollable content, line numbers, +// scrollbar, vim navigation, and mouse support. +type Overlay struct { + content ContentView + title string + visible bool + width int + height int +} + +func NewOverlay() Overlay { + return Overlay{} +} + +func (o *Overlay) Show(title, content string, w, h int) { + o.visible = true + o.title = title + o.width = w + o.height = h + + innerW := w - 4 // border + padding + innerH := h - 4 // title + hint + borders + if innerW < 40 { + innerW = 40 + } + if innerH < 10 { + innerH = 10 + } + + o.content = NewContentView(innerW, innerH) + o.content.SetContent(content) +} + +func (o *Overlay) Hide() { o.visible = false } +func (o Overlay) IsVisible() bool { return o.visible } + +func (o Overlay) Update(msg tea.Msg) (Overlay, tea.Cmd) { + if !o.visible { + return o, nil + } + + switch msg := msg.(type) { + case tea.KeyMsg: + // When searching, forward all keys to content (including esc to close search) + if o.content.IsSearching() { + var cmd tea.Cmd + o.content, cmd = o.content.Update(msg) + return o, cmd + } + switch msg.String() { + case "esc", "q": + o.visible = false + return o, nil + } + } + + var cmd tea.Cmd + o.content, cmd = o.content.Update(msg) + return o, cmd +} + +func (o Overlay) View() string { + if !o.visible { + return "" + } + + titleSt := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("39")) + dimSt := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + keySt := lipgloss.NewStyle().Foreground(lipgloss.Color("63")).Bold(true) + + titleBar := titleSt.Render(o.title) + + // Scroll info + pct := fmt.Sprintf("%d%%", int(o.content.ScrollPercent()*100)) + lineInfo := fmt.Sprintf("L%d/%d", o.content.YOffset()+1, o.content.TotalLines()) + scrollInfo := dimSt.Render(lineInfo + " " + pct) + + // Hints + var hints []string + hints = append(hints, keySt.Render("j/k")+" "+dimSt.Render("scroll")) + hints = append(hints, keySt.Render("/")+" "+dimSt.Render("search")) + if si := o.content.SearchInfo(); si != "" { + activeSt := lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true) + hints = append(hints, keySt.Render("n/N")+" "+activeSt.Render(si)) + } + hints = append(hints, keySt.Render("g/G")+" "+dimSt.Render("top/end")) + hints = append(hints, keySt.Render("Esc")+" "+dimSt.Render("close")) + hintBar := strings.Join(hints, " ") + " " + scrollInfo + + box := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("63")). + Padding(0, 1). + Render(titleBar + "\n" + o.content.View() + "\n" + hintBar) + + return lipgloss.Place(o.width, o.height, + lipgloss.Center, lipgloss.Center, + box, + lipgloss.WithWhitespaceBackground(lipgloss.Color("0"))) +} diff --git a/tui/panels/breadcrumb.go b/tui/panels/breadcrumb.go new file mode 100644 index 0000000..4a32866 --- /dev/null +++ b/tui/panels/breadcrumb.go @@ -0,0 +1,99 @@ +package panels + +import ( + "strings" + + "github.com/charmbracelet/lipgloss" +) + +var ( + breadcrumbSeparator = " > " + breadcrumbNormalStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("252")) + breadcrumbActiveStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("255")).Bold(true) + breadcrumbSepStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + breadcrumbEllipsisStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("240")) +) + +// BreadcrumbSegment represents a single level in the navigation path. +type BreadcrumbSegment struct { + Label string +} + +// Breadcrumb renders a navigable path like "Project > MyModule > Entities". +type Breadcrumb struct { + segments []BreadcrumbSegment + width int +} + +// Push appends a segment to the breadcrumb trail. +func (b *Breadcrumb) Push(label string) { + b.segments = append(b.segments, BreadcrumbSegment{Label: label}) +} + +// PopTo truncates the breadcrumb to the given depth (0 = empty, 1 = first segment only). +func (b *Breadcrumb) PopTo(level int) { + if level < 0 { + level = 0 + } + if level < len(b.segments) { + b.segments = b.segments[:level] + } +} + +// Depth returns the current number of segments. +func (b *Breadcrumb) Depth() int { + return len(b.segments) +} + +// SetWidth sets the available width for truncation. +func (b *Breadcrumb) SetWidth(w int) { + b.width = w +} + +// View renders the breadcrumb as a styled string. +func (b *Breadcrumb) View() string { + if len(b.segments) == 0 { + return "" + } + + sep := breadcrumbSepStyle.Render(breadcrumbSeparator) + lastIdx := len(b.segments) - 1 + + var parts []string + for i, seg := range b.segments { + if i == lastIdx { + parts = append(parts, breadcrumbActiveStyle.Render(seg.Label)) + } else { + parts = append(parts, breadcrumbNormalStyle.Render(seg.Label)) + } + } + + rendered := strings.Join(parts, sep) + + if b.width > 0 && lipgloss.Width(rendered) > b.width { + ellipsis := breadcrumbEllipsisStyle.Render("...") + for len(parts) > 2 { + parts = append(parts[:1], parts[2:]...) + candidate := parts[0] + sep + ellipsis + sep + strings.Join(parts[1:], sep) + if lipgloss.Width(candidate) <= b.width { + return candidate + } + } + } + + return rendered +} + +// ClickedSegment returns the segment index at the given x position, or -1 if none. +// Uses plain-text character counting (labels + " > " separators). +func (b *Breadcrumb) ClickedSegment(x int) int { + pos := 0 + for i, seg := range b.segments { + end := pos + len(seg.Label) + if x >= pos && x < end { + return i + } + pos = end + len(breadcrumbSeparator) // skip " > " + } + return -1 +} diff --git a/tui/panels/elements.go b/tui/panels/elements.go new file mode 100644 index 0000000..0d21a4d --- /dev/null +++ b/tui/panels/elements.go @@ -0,0 +1,82 @@ +package panels + +import ( + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// elementItem wraps TreeNode with a display label for the elements panel. +type elementItem struct { + node *TreeNode + displayLabel string +} + +func (e elementItem) Label() string { return e.displayLabel } +func (e elementItem) Icon() string { return iconFor(e.node.Type) } +func (e elementItem) Description() string { return e.node.Type } +func (e elementItem) FilterValue() string { return e.node.Label } + +// ElementsPanel is the middle column: children of the selected module node. +type ElementsPanel struct { + scrollList ScrollList + nodes []*TreeNode + focused bool + width int + height int +} + +func NewElementsPanel(width, height int) ElementsPanel { + sl := NewScrollList("Elements") + sl.SetSize(width-2, height-2) + return ElementsPanel{scrollList: sl, width: width, height: height} +} + +func (p *ElementsPanel) SetNodes(nodes []*TreeNode) { + p.nodes = nodes + items := make([]ScrollListItem, len(nodes)) + for i, n := range nodes { + label := n.Label + if len(n.Children) > 0 { + label += " ▶" + } + items[i] = elementItem{ + node: n, + displayLabel: label, + } + } + p.scrollList.SetItems(items) +} + +func (p ElementsPanel) SelectedNode() *TreeNode { + selected := p.scrollList.SelectedItem() + if selected == nil { + return nil + } + return selected.(elementItem).node +} + +func (p *ElementsPanel) SetSize(w, h int) { + p.width = w + p.height = h + p.scrollList.SetSize(w-2, h-2) +} + +func (p ElementsPanel) IsFilterActive() bool { return p.scrollList.IsFilterActive() } + +func (p *ElementsPanel) SetFocused(f bool) { + p.focused = f + p.scrollList.SetFocused(f) +} + +func (p ElementsPanel) Update(msg tea.Msg) (ElementsPanel, tea.Cmd) { + var cmd tea.Cmd + p.scrollList, cmd = p.scrollList.Update(msg) + return p, cmd +} + +func (p ElementsPanel) View() string { + border := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(borderColor(p.focused)) + return border.Render(p.scrollList.View()) +} diff --git a/tui/panels/icons.go b/tui/panels/icons.go new file mode 100644 index 0000000..adf0d2e --- /dev/null +++ b/tui/panels/icons.go @@ -0,0 +1,65 @@ +package panels + +var typeIconMap = map[string]string{ + // Project-level nodes + "systemoverview": "🗺", + "navigation": "🧭", + "projectsecurity": "🛡", + + // Modules & structure + "module": "⬡", + "folder": "📁", + "category": "⊟", + + // Domain model + "domainmodel": "⊞", + "entity": "▣", + "externalentity": "⊡", + "association": "↔", + "enumeration": "≡", + + // Logic + "microflow": "⚙", + "nanoflow": "⚡", + "workflow": "🔀", + + // UI + "page": "▤", + "snippet": "⬔", + "layout": "⬕", + + // Constants & events + "constant": "π", + "scheduledevent": "⏰", + + // Actions + "javaaction": "☕", + "javascriptaction": "JS", + + // Security + "security": "🔒", + "modulerole": "👤", + "userrole": "👥", + + // Services & integrations + "businesseventservice": "📡", + "databaseconnection": "🗄", + "odataservice": "🌐", + "odataclient": "🔗", + "publishedrestservice": "🌍", + "consumedrestservice": "🔌", + + // Navigation sub-types + "navprofile": "⊕", + "navhome": "⌂", + "navmenu": "☰", + "navmenuitem": "→", +} + +// iconFor returns the icon for a Mendix node type, or "·" if unknown. +func iconFor(nodeType string) string { + if icon, ok := typeIconMap[nodeType]; ok { + return icon + } + return "·" +} diff --git a/tui/panels/modules.go b/tui/panels/modules.go new file mode 100644 index 0000000..05ff847 --- /dev/null +++ b/tui/panels/modules.go @@ -0,0 +1,159 @@ +package panels + +import ( + "encoding/json" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// TreeNode mirrors cmd/mxcli.TreeNode for JSON parsing. +type TreeNode struct { + Label string `json:"label"` + Type string `json:"type"` + QualifiedName string `json:"qualifiedName,omitempty"` + Children []*TreeNode `json:"children,omitempty"` +} + +// nodeItem wraps TreeNode to implement ScrollListItem. +type nodeItem struct{ node *TreeNode } + +func (n nodeItem) Label() string { return n.node.Label } +func (n nodeItem) Icon() string { return iconFor(n.node.Type) } +func (n nodeItem) Description() string { return "" } +func (n nodeItem) FilterValue() string { return n.node.Label } + +// ModulesPanel is the left column: a list of top-level tree nodes (modules + special nodes). +type ModulesPanel struct { + scrollList ScrollList + nodes []*TreeNode + navigationStack [][]*TreeNode + breadcrumb Breadcrumb + focused bool + width int + height int +} + +func NewModulesPanel(width, height int) ModulesPanel { + sl := NewScrollList("Project") + sl.SetSize(width, height-2) // reserve space for border + return ModulesPanel{scrollList: sl, width: width, height: height} +} + +// LoadTreeMsg carries parsed tree nodes from project-tree output. +type LoadTreeMsg struct { + Nodes []*TreeNode + Err error +} + +// ParseTree parses JSON from mxcli project-tree output. +func ParseTree(jsonStr string) ([]*TreeNode, error) { + var nodes []*TreeNode + if err := json.Unmarshal([]byte(jsonStr), &nodes); err != nil { + return nil, err + } + return nodes, nil +} + +func (p *ModulesPanel) SetNodes(nodes []*TreeNode) { + p.nodes = nodes + p.navigationStack = nil + p.breadcrumb = Breadcrumb{} + p.breadcrumb.SetWidth(p.width - 4) + p.setScrollListNodes(nodes) +} + +func (p *ModulesPanel) setScrollListNodes(nodes []*TreeNode) { + items := make([]ScrollListItem, len(nodes)) + for i, n := range nodes { + items[i] = nodeItem{node: n} + } + p.scrollList.SetItems(items) +} + +// DrillIn pushes current nodes onto the stack and displays children. +func (p *ModulesPanel) DrillIn(parentLabel string, children []*TreeNode) { + p.navigationStack = append(p.navigationStack, p.currentNodes()) + p.breadcrumb.Push(parentLabel) + p.setScrollListNodes(children) +} + +// DrillBack pops the navigation stack and returns true if it went back, false if already at root. +func (p *ModulesPanel) DrillBack() bool { + depth := len(p.navigationStack) + if depth == 0 { + return false + } + prev := p.navigationStack[depth-1] + p.navigationStack = p.navigationStack[:depth-1] + p.breadcrumb.PopTo(p.breadcrumb.Depth() - 1) + p.setScrollListNodes(prev) + return true +} + +func (p *ModulesPanel) currentNodes() []*TreeNode { + total := len(p.scrollList.items) + nodes := make([]*TreeNode, total) + for i, item := range p.scrollList.items { + nodes[i] = item.(nodeItem).node + } + return nodes +} + +func (p ModulesPanel) SelectedNode() *TreeNode { + selected := p.scrollList.SelectedItem() + if selected == nil { + return nil + } + return selected.(nodeItem).node +} + +func (p *ModulesPanel) SetSize(w, h int) { + p.width = w + p.height = h + bcHeight := 0 + if p.breadcrumb.Depth() > 0 { + bcHeight = 1 + } + p.scrollList.SetSize(w-2, h-2-bcHeight) // subtract border + optional breadcrumb + p.breadcrumb.SetWidth(w - 4) +} + +func (p ModulesPanel) IsFilterActive() bool { return p.scrollList.IsFilterActive() } + +func (p *ModulesPanel) SetFocused(f bool) { + p.focused = f + p.scrollList.SetFocused(f) +} + +func (p ModulesPanel) Update(msg tea.Msg) (ModulesPanel, tea.Cmd) { + // Adjust mouse Y for breadcrumb height before forwarding to scroll list + if mouseMsg, ok := msg.(tea.MouseMsg); ok && p.breadcrumb.Depth() > 0 { + mouseMsg.Y -= 1 // breadcrumb line + msg = mouseMsg + } + var cmd tea.Cmd + p.scrollList, cmd = p.scrollList.Update(msg) + return p, cmd +} + +func (p ModulesPanel) View() string { + border := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(borderColor(p.focused)) + + var content string + if p.breadcrumb.Depth() > 0 { + content = p.breadcrumb.View() + "\n" + p.scrollList.View() + } else { + content = p.scrollList.View() + } + return border.Render(content) +} + +func borderColor(focused bool) lipgloss.Color { + if focused { + return lipgloss.Color("63") + } + return lipgloss.Color("240") +} diff --git a/tui/panels/preview.go b/tui/panels/preview.go new file mode 100644 index 0000000..32e8f93 --- /dev/null +++ b/tui/panels/preview.go @@ -0,0 +1,159 @@ +package panels + +import ( + "fmt" + "strings" + + "github.com/charmbracelet/bubbles/viewport" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// HighlightFunc is a function that applies syntax highlighting to content. +// Set by the tui package to avoid circular imports. +var HighlightFunc func(string) string + +// PreviewPanel is the right column: DESCRIBE output in a scrollable viewport. +type PreviewPanel struct { + viewport viewport.Model + focused bool + loading bool + width int + height int + summaryContent string + fullContent string + selectedNode *TreeNode +} + +// DescribeResultMsg carries DESCRIBE output. +type DescribeResultMsg struct { + Content string + Err error +} + +// OpenOverlayMsg requests that the overlay be shown with highlighted full content. +type OpenOverlayMsg struct { + Title string + Content string +} + +func NewPreviewPanel(width, height int) PreviewPanel { + vp := viewport.New(width, height) + vp.SetContent("Select an element to preview its DESCRIBE output.") + return PreviewPanel{viewport: vp, width: width, height: height} +} + +func (p *PreviewPanel) SetContent(content string) { + p.loading = false + p.fullContent = content + p.summaryContent = buildSummary(content) + p.viewport.SetContent(p.summaryContent) + p.viewport.GotoTop() +} + +func (p *PreviewPanel) SetLoading() { + p.loading = true + p.viewport.SetContent("Loading...") +} + +func (p *PreviewPanel) SetSize(w, h int) { + p.width = w + p.height = h + p.viewport.Width = w + p.viewport.Height = h +} + +func (p *PreviewPanel) SetFocused(f bool) { p.focused = f } + +func (p *PreviewPanel) SetSelectedNode(node *TreeNode) { + p.selectedNode = node +} + +// FullContent returns the full DESCRIBE output for overlay display. +func (p PreviewPanel) FullContent() string { + return p.fullContent +} + +func (p PreviewPanel) Update(msg tea.Msg) (PreviewPanel, tea.Cmd) { + if keyMsg, ok := msg.(tea.KeyMsg); ok && keyMsg.String() == "enter" && p.fullContent != "" { + title := "Preview" + if p.selectedNode != nil { + title = fmt.Sprintf("%s %s", p.selectedNode.Type, p.selectedNode.QualifiedName) + } + content := p.fullContent + if HighlightFunc != nil { + content = HighlightFunc(content) + } + return p, func() tea.Msg { + return OpenOverlayMsg{Title: title, Content: content} + } + } + + var cmd tea.Cmd + p.viewport, cmd = p.viewport.Update(msg) + return p, cmd +} + +func (p PreviewPanel) View() string { + title := "Preview" + if p.loading { + title = "Preview (loading...)" + } + header := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("39")).Render(title) + border := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(borderColor(p.focused)) + return border.Render(header + "\n" + p.viewport.View()) +} + +// buildSummary extracts key metadata lines from DESCRIBE output. +func buildSummary(content string) string { + if content == "" { + return content + } + + lines := strings.Split(content, "\n") + var summary []string + attrCount := 0 + inAttributes := false + + for _, line := range lines { + trimmed := strings.TrimSpace(line) + + // Keep header lines (Type, Name, Module, etc.) + for _, prefix := range []string{ + "-- Type:", "-- Name:", "-- Module:", "-- Qualified", + "CREATE ", "ALTER ", "-- Documentation", + "-- Return", "-- Persistent", "-- Generalization", + } { + if strings.HasPrefix(trimmed, prefix) { + summary = append(summary, line) + break + } + } + + // Count attributes/parameters + if strings.Contains(trimmed, "ATTRIBUTE") || strings.Contains(trimmed, "PARAMETER") { + if !inAttributes { + inAttributes = true + } + attrCount++ + } + } + + if attrCount > 0 { + summary = append(summary, fmt.Sprintf("\n %d attribute(s)/parameter(s)", attrCount)) + } + + if len(summary) == 0 { + // Fallback: show first 15 lines + limit := 15 + if len(lines) < limit { + limit = len(lines) + } + return strings.Join(lines[:limit], "\n") + } + + summary = append(summary, "\n [Enter] full view") + return strings.Join(summary, "\n") +} diff --git a/tui/panels/scrolllist.go b/tui/panels/scrolllist.go new file mode 100644 index 0000000..d59088e --- /dev/null +++ b/tui/panels/scrolllist.go @@ -0,0 +1,393 @@ +package panels + +import ( + "strings" + + "github.com/charmbracelet/bubbles/textinput" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +// ScrollListItem is the interface for items displayed in a ScrollList. +type ScrollListItem interface { + Label() string + Icon() string + Description() string + FilterValue() string +} + +// ScrollList is a scrollable list with filtering, mouse support, and a visual scrollbar. +type ScrollList struct { + items []ScrollListItem + filteredItems []int // indices into items + cursor int + scrollOffset int + + filterInput textinput.Model + filterActive bool + + title string + width int + height int + focused bool + headerHeight int // lines consumed by title + filter bar +} + +// NewScrollList creates a ScrollList with the given title. +func NewScrollList(title string) ScrollList { + ti := textinput.New() + ti.Prompt = "/ " + ti.CharLimit = 200 + + return ScrollList{ + title: title, + filterInput: ti, + headerHeight: 1, // title line only + } +} + +// SetItems replaces the item list and resets cursor/scroll state. +func (s *ScrollList) SetItems(items []ScrollListItem) { + s.items = items + s.cursor = 0 + s.scrollOffset = 0 + s.rebuildFiltered() +} + +// SelectedIndex returns the index of the selected item in the original items slice, or -1. +func (s ScrollList) SelectedIndex() int { + if len(s.filteredItems) == 0 { + return -1 + } + if s.cursor >= len(s.filteredItems) { + return -1 + } + return s.filteredItems[s.cursor] +} + +// SelectedItem returns the currently selected item, or nil. +func (s ScrollList) SelectedItem() ScrollListItem { + idx := s.SelectedIndex() + if idx < 0 || idx >= len(s.items) { + return nil + } + return s.items[idx] +} + +// SetSize updates the list dimensions. +func (s *ScrollList) SetSize(w, h int) { + s.width = w + s.height = h +} + +// SetFocused sets the focus state for visual styling. +func (s *ScrollList) SetFocused(f bool) { + s.focused = f +} + +// MaxVisible returns the number of visible item rows given current height. +func (s ScrollList) MaxVisible() int { + hdr := s.headerHeight + if s.filterActive { + hdr++ // filter input line + } + visible := s.height - hdr + if visible < 1 { + return 1 + } + return visible +} + +// IsFilterActive returns true if the filter input is active. +func (s ScrollList) IsFilterActive() bool { return s.filterActive } + +// ToggleFilter activates or deactivates the filter input. +func (s *ScrollList) ToggleFilter() { + if s.filterActive { + s.deactivateFilter() + } else { + s.filterActive = true + s.filterInput.SetValue("") + s.filterInput.Focus() + s.rebuildFiltered() + } +} + +// ClearFilter deactivates filter and shows all items. +func (s *ScrollList) ClearFilter() { + s.deactivateFilter() +} + +func (s *ScrollList) deactivateFilter() { + s.filterActive = false + s.filterInput.SetValue("") + s.filterInput.Blur() + s.rebuildFiltered() +} + +func (s *ScrollList) rebuildFiltered() { + s.filteredItems = s.filteredItems[:0] + query := strings.ToLower(strings.TrimSpace(s.filterInput.Value())) + for i, item := range s.items { + if query == "" || strings.Contains(strings.ToLower(item.FilterValue()), query) { + s.filteredItems = append(s.filteredItems, i) + } + } + if s.cursor >= len(s.filteredItems) { + s.cursor = max(0, len(s.filteredItems)-1) + } + s.clampScroll() +} + +func (s *ScrollList) clampScroll() { + maxVis := s.MaxVisible() + total := len(s.filteredItems) + if s.scrollOffset > total-maxVis { + s.scrollOffset = max(0, total-maxVis) + } + if s.scrollOffset < 0 { + s.scrollOffset = 0 + } +} + +func (s *ScrollList) cursorDown() { + total := len(s.filteredItems) + if total == 0 { + return + } + s.cursor++ + if s.cursor >= total { + s.cursor = 0 + s.scrollOffset = 0 + return + } + maxVis := s.MaxVisible() + if s.cursor >= s.scrollOffset+maxVis { + s.scrollOffset = s.cursor - maxVis + 1 + } +} + +func (s *ScrollList) cursorUp() { + total := len(s.filteredItems) + if total == 0 { + return + } + s.cursor-- + if s.cursor < 0 { + s.cursor = total - 1 + s.scrollOffset = max(0, s.cursor-s.MaxVisible()+1) + return + } + if s.cursor < s.scrollOffset { + s.scrollOffset = s.cursor + } +} + +// Update handles keyboard and mouse messages. +func (s ScrollList) Update(msg tea.Msg) (ScrollList, tea.Cmd) { + switch msg := msg.(type) { + case tea.KeyMsg: + if s.filterActive { + switch msg.String() { + case "esc": + s.deactivateFilter() + return s, nil + case "enter": + // Lock in filter, exit filter mode but keep results + s.filterActive = false + s.filterInput.Blur() + return s, nil + case "up": + s.cursorUp() + return s, nil + case "down": + s.cursorDown() + return s, nil + default: + var cmd tea.Cmd + s.filterInput, cmd = s.filterInput.Update(msg) + s.rebuildFiltered() + return s, cmd + } + } + + switch msg.String() { + case "j", "down": + s.cursorDown() + case "k", "up": + s.cursorUp() + case "/": + s.ToggleFilter() + case "G": + total := len(s.filteredItems) + if total > 0 { + s.cursor = total - 1 + maxVis := s.MaxVisible() + s.scrollOffset = max(0, total-maxVis) + } + case "g": + s.cursor = 0 + s.scrollOffset = 0 + } + + case tea.MouseMsg: + switch msg.Action { + case tea.MouseActionPress: + switch msg.Button { + case tea.MouseButtonWheelUp: + s.scrollUp(3) + case tea.MouseButtonWheelDown: + s.scrollDown(3) + case tea.MouseButtonLeft: + topOffset := s.headerHeight + if s.filterActive { + topOffset++ + } + clicked := s.scrollOffset + (msg.Y - topOffset) + if clicked >= 0 && clicked < len(s.filteredItems) { + s.cursor = clicked + } + } + } + } + return s, nil +} + +func (s *ScrollList) scrollUp(n int) { + s.scrollOffset -= n + if s.scrollOffset < 0 { + s.scrollOffset = 0 + } + if s.cursor >= s.scrollOffset+s.MaxVisible() { + s.cursor = s.scrollOffset + s.MaxVisible() - 1 + } +} + +func (s *ScrollList) scrollDown(n int) { + total := len(s.filteredItems) + maxVis := s.MaxVisible() + s.scrollOffset += n + if s.scrollOffset > total-maxVis { + s.scrollOffset = max(0, total-maxVis) + } + if s.cursor < s.scrollOffset { + s.cursor = s.scrollOffset + } +} + +// View renders the list with scrollbar. +func (s ScrollList) View() string { + var sb strings.Builder + + titleSt := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("39")) + selectedSt := s.selectedStyle() + normalSt := lipgloss.NewStyle().Foreground(lipgloss.Color("245")) + descSt := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + trackSt := lipgloss.NewStyle().Foreground(lipgloss.Color("238")) + thumbSt := lipgloss.NewStyle().Foreground(lipgloss.Color("63")) + filterLabelSt := lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true) + + // Title + sb.WriteString(titleSt.Render(s.title) + "\n") + + // Filter bar + if s.filterActive { + sb.WriteString(s.filterInput.View()) + sb.WriteString("\n") + } else if s.filterInput.Value() != "" { + sb.WriteString(filterLabelSt.Render("Filter: " + s.filterInput.Value())) + sb.WriteString("\n") + } + + total := len(s.filteredItems) + maxVis := s.MaxVisible() + + // Content width for items (reserve 1 col for scrollbar if needed) + contentWidth := s.width - 2 // subtract padding + showScrollbar := total > maxVis + if showScrollbar { + contentWidth-- // reserve 1 for scrollbar + } + if contentWidth < 10 { + contentWidth = 10 + } + + // Scrollbar geometry + var thumbStart, thumbEnd int + if showScrollbar { + trackHeight := maxVis + if total <= maxVis { + thumbStart = 0 + thumbEnd = trackHeight + } else { + thumbSize := max(1, trackHeight*maxVis/total) + maxOffset := total - maxVis + thumbStart = s.scrollOffset * (trackHeight - thumbSize) / maxOffset + thumbEnd = thumbStart + thumbSize + } + } + + for vi := range maxVis { + idx := s.scrollOffset + vi + var line string + if idx < total { + itemIdx := s.filteredItems[idx] + item := s.items[itemIdx] + icon := item.Icon() + if icon == "" { + icon = "·" + } + label := icon + " " + item.Label() + + desc := item.Description() + if desc != "" { + label += " " + descSt.Render(desc) + } + + // Truncate to fit + if lipgloss.Width(label) > contentWidth-4 { + label = label[:contentWidth-4] + } + + if idx == s.cursor { + line = selectedSt.Render("> " + label) + } else { + line = normalSt.Render(" " + label) + } + } else { + line = "" + } + + // Pad line to contentWidth + lineWidth := lipgloss.Width(line) + if lineWidth < contentWidth { + line += strings.Repeat(" ", contentWidth-lineWidth) + } + + // Append scrollbar character + if showScrollbar { + if vi >= thumbStart && vi < thumbEnd { + line += thumbSt.Render("█") + } else { + line += trackSt.Render("│") + } + } + + sb.WriteString(line) + if vi < maxVis-1 { + sb.WriteString("\n") + } + } + + return sb.String() +} + +func (s ScrollList) selectedStyle() lipgloss.Style { + if s.focused { + return lipgloss.NewStyle(). + Foreground(lipgloss.Color("255")). + Bold(true) + } + return lipgloss.NewStyle(). + Foreground(lipgloss.Color("245")) +} diff --git a/tui/picker.go b/tui/picker.go new file mode 100644 index 0000000..09ae61e --- /dev/null +++ b/tui/picker.go @@ -0,0 +1,421 @@ +// SPDX-License-Identifier: Apache-2.0 + +package tui + +import ( + "os" + "path/filepath" + "strings" + + "github.com/charmbracelet/bubbles/textinput" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" +) + +const pickerMaxVisible = 8 + +// pathCandidate is a filesystem entry shown during path completion. +type pathCandidate struct { + fullPath string + name string + isDir bool + isMPR bool + isMendixDir bool // directory that contains at least one .mpr file + enriched bool // whether isMendixDir has been checked +} + +func (c pathCandidate) icon() string { + switch { + case c.isMPR: + return "⬡" + case c.isMendixDir: + return "⬡" + case c.isDir: + return "📁" + default: + return "·" + } +} + +// dirContainsMPR returns true if dir has at least one .mpr file (non-recursive). +func dirContainsMPR(dir string) bool { + entries, err := os.ReadDir(dir) + if err != nil { + return false + } + for _, e := range entries { + if !e.IsDir() && strings.HasSuffix(strings.ToLower(e.Name()), ".mpr") { + return true + } + } + return false +} + +// dirSingleMPR returns the single .mpr path if the directory contains exactly one .mpr file. +func dirSingleMPR(dir string) string { + entries, err := os.ReadDir(dir) + if err != nil { + return "" + } + var found string + for _, e := range entries { + if !e.IsDir() && strings.HasSuffix(strings.ToLower(e.Name()), ".mpr") { + if found != "" { + return "" // more than one + } + found = filepath.Join(dir, e.Name()) + } + } + return found +} + +// listPathCandidates lists filesystem entries matching the current input prefix. +func listPathCandidates(input string) []pathCandidate { + dir := input + prefix := "" + + if !strings.HasSuffix(input, string(os.PathSeparator)) { + dir = filepath.Dir(input) + prefix = strings.ToLower(filepath.Base(input)) + } + + entries, err := os.ReadDir(dir) + if err != nil { + return nil + } + + var candidates []pathCandidate + for _, e := range entries { + if prefix != "" && !strings.HasPrefix(strings.ToLower(e.Name()), prefix) { + continue + } + full := filepath.Join(dir, e.Name()) + isMPR := !e.IsDir() && strings.HasSuffix(strings.ToLower(e.Name()), ".mpr") + candidates = append(candidates, pathCandidate{ + fullPath: full, + name: e.Name(), + isDir: e.IsDir(), + isMPR: isMPR, + }) + } + return candidates +} + +// PickerModel lets the user select from recent projects or type a new path. +type PickerModel struct { + history []string + cursor int + historyScrollOffset int + + input textinput.Model + inputMode bool + pathCandidates []pathCandidate + pathCursor int + pathScrollOffset int + + chosen string + done bool + width int + height int +} + +// NewPickerModel creates the picker model with loaded history. +func NewPickerModel() PickerModel { + ti := textinput.New() + ti.Placeholder = "/path/to/App.mpr" + ti.Prompt = " Path: " + ti.CharLimit = 500 + + return PickerModel{ + history: LoadHistory(), + input: ti, + } +} + +// Chosen returns the selected project path (empty if cancelled). +func (m PickerModel) Chosen() string { + return m.chosen +} + +func (m PickerModel) Init() tea.Cmd { + return nil +} + +// enrichVisible populates isMendixDir only for candidates within the visible window. +func (m *PickerModel) enrichVisible() { + end := m.pathScrollOffset + pickerMaxVisible + if end > len(m.pathCandidates) { + end = len(m.pathCandidates) + } + for i := m.pathScrollOffset; i < end; i++ { + c := &m.pathCandidates[i] + if c.isDir && !c.enriched { + c.isMendixDir = dirContainsMPR(c.fullPath) + c.enriched = true + } + } +} + +func (m *PickerModel) refreshCandidates() { + val := strings.TrimSpace(m.input.Value()) + if val == "" { + m.pathCandidates = nil + m.pathCursor = 0 + m.pathScrollOffset = 0 + return + } + m.pathCandidates = listPathCandidates(val) + if m.pathCursor >= len(m.pathCandidates) { + m.pathCursor = 0 + m.pathScrollOffset = 0 + } + m.enrichVisible() +} + +func (m *PickerModel) pathCursorDown() { + if len(m.pathCandidates) == 0 { + return + } + m.pathCursor++ + if m.pathCursor >= len(m.pathCandidates) { + m.pathCursor = 0 + m.pathScrollOffset = 0 + } else if m.pathCursor >= m.pathScrollOffset+pickerMaxVisible { + m.pathScrollOffset = m.pathCursor - pickerMaxVisible + 1 + } + m.enrichVisible() +} + +func (m *PickerModel) pathCursorUp() { + if len(m.pathCandidates) == 0 { + return + } + m.pathCursor-- + if m.pathCursor < 0 { + m.pathCursor = len(m.pathCandidates) - 1 + m.pathScrollOffset = max(0, m.pathCursor-pickerMaxVisible+1) + } else if m.pathCursor < m.pathScrollOffset { + m.pathScrollOffset = m.pathCursor + } + m.enrichVisible() +} + +func (m *PickerModel) applyCandidate() bool { + if len(m.pathCandidates) == 0 { + return false + } + c := m.pathCandidates[m.pathCursor] + if c.isDir { + // If the directory has exactly one .mpr, open it directly + if single := dirSingleMPR(c.fullPath); single != "" { + m.chosen = single + m.done = true + return true + } + m.input.SetValue(c.fullPath + string(os.PathSeparator)) + } else { + m.input.SetValue(c.fullPath) + } + m.input.CursorEnd() + m.pathCursor = 0 + m.pathScrollOffset = 0 + m.refreshCandidates() + return false +} + +func (m PickerModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + switch msg := msg.(type) { + case tea.WindowSizeMsg: + m.width = msg.Width + m.height = msg.Height + + case tea.KeyMsg: + if m.inputMode { + switch msg.String() { + case "esc": + m.inputMode = false + m.pathCandidates = nil + m.pathCursor = 0 + m.pathScrollOffset = 0 + m.input.Blur() + return m, nil + + case "tab": + if len(m.pathCandidates) > 0 { + if done := m.applyCandidate(); done { + return m, tea.Quit + } + } + return m, nil + + case "up": + m.pathCursorUp() + return m, nil + + case "down": + m.pathCursorDown() + return m, nil + + case "enter": + if len(m.pathCandidates) > 0 { + if done := m.applyCandidate(); done { + return m, tea.Quit + } + // If it was a dir without unique mpr, stay in input mode + if len(m.pathCandidates) > 0 { + return m, nil + } + } + val := strings.TrimSpace(m.input.Value()) + if val != "" { + m.chosen = val + m.done = true + return m, tea.Quit + } + + default: + var cmd tea.Cmd + m.input, cmd = m.input.Update(msg) + m.pathCursor = 0 + m.pathScrollOffset = 0 + m.refreshCandidates() + return m, cmd + } + } else { + switch msg.String() { + case "ctrl+c", "q": + m.done = true + return m, tea.Quit + + case "j", "down": + if m.cursor < len(m.history)-1 { + m.cursor++ + if m.cursor >= m.historyScrollOffset+pickerMaxVisible { + m.historyScrollOffset = m.cursor - pickerMaxVisible + 1 + } + } + + case "k", "up": + if m.cursor > 0 { + m.cursor-- + if m.cursor < m.historyScrollOffset { + m.historyScrollOffset = m.cursor + } + } + + case "enter": + if len(m.history) > 0 { + m.chosen = m.history[m.cursor] + m.done = true + return m, tea.Quit + } + + case "n": + m.inputMode = true + m.input.SetValue("") + m.pathCandidates = nil + m.pathCursor = 0 + m.pathScrollOffset = 0 + m.input.Focus() + return m, nil + } + } + } + return m, nil +} + +func (m PickerModel) View() string { + selectedStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("255")).Bold(true) + normalStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("245")) + dimStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("240")) + highlightStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("63")).Bold(true) + mprStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true) + titleStyle := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("63")) + + var sb strings.Builder + sb.WriteString(titleStyle.Render("Select Mendix Project") + "\n\n") + + if !m.inputMode { + if len(m.history) == 0 { + sb.WriteString(dimStyle.Render("No recent projects.") + "\n\n") + } else { + sb.WriteString(dimStyle.Render("Recent projects:") + "\n") + end := m.historyScrollOffset + pickerMaxVisible + if end > len(m.history) { + end = len(m.history) + } + if m.historyScrollOffset > 0 { + sb.WriteString(dimStyle.Render(" ↑ more above") + "\n") + } + for i := m.historyScrollOffset; i < end; i++ { + path := m.history[i] + if i == m.cursor { + sb.WriteString(selectedStyle.Render("> ⬡ "+path) + "\n") + } else { + sb.WriteString(normalStyle.Render(" ⬡ "+path) + "\n") + } + } + if end < len(m.history) { + sb.WriteString(dimStyle.Render(" ↓ more below") + "\n") + } + sb.WriteString("\n") + } + hint := "[n] new path [q] quit" + if len(m.history) > 0 { + hint = "[j/k] navigate [Enter] open [n] new path [q] quit" + } + sb.WriteString(dimStyle.Render(hint) + "\n") + } else { + sb.WriteString(m.input.View() + "\n") + + if len(m.pathCandidates) == 0 { + sb.WriteString("\n") + sb.WriteString(dimStyle.Render("[Tab] complete [Enter] confirm [Esc] back") + "\n") + } else { + sb.WriteString("\n") + end := m.pathScrollOffset + pickerMaxVisible + if end > len(m.pathCandidates) { + end = len(m.pathCandidates) + } + if m.pathScrollOffset > 0 { + sb.WriteString(dimStyle.Render(" ↑ more above") + "\n") + } + for i := m.pathScrollOffset; i < end; i++ { + c := m.pathCandidates[i] + icon := c.icon() + suffix := "" + if c.isDir { + suffix = "/" + } + label := icon + " " + c.name + suffix + if i == m.pathCursor { + if c.isMPR || c.isMendixDir { + sb.WriteString(mprStyle.Render("> "+label) + "\n") + } else { + sb.WriteString(highlightStyle.Render("> "+label) + "\n") + } + } else { + sb.WriteString(normalStyle.Render(" "+label) + "\n") + } + } + if end < len(m.pathCandidates) { + sb.WriteString(dimStyle.Render(" ↓ more below") + "\n") + } + sb.WriteString("\n") + sb.WriteString(dimStyle.Render("[↑↓] navigate [Tab/Enter] open [Esc] back") + "\n") + } + } + + boxStyle := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("63")). + Padding(1, 2). + Width(70) + + content := boxStyle.Render(sb.String()) + + if m.width > 0 && m.height > 0 { + return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, content) + } + return content +} diff --git a/tui/runner.go b/tui/runner.go new file mode 100644 index 0000000..4d58a05 --- /dev/null +++ b/tui/runner.go @@ -0,0 +1,33 @@ +package tui + +import ( + "bytes" + "os/exec" + "strings" +) + +// runMxcli runs a mxcli subcommand and returns stdout. +// mxcliPath is the path to the mxcli binary (os.Args[0] works for self). +func runMxcli(mxcliPath string, args ...string) (string, error) { + var buf bytes.Buffer + var errBuf bytes.Buffer + cmd := exec.Command(mxcliPath, args...) + cmd.Stdout = &buf + cmd.Stderr = &errBuf + if err := cmd.Run(); err != nil { + combined := strings.TrimSpace(buf.String() + "\n" + errBuf.String()) + return combined, err + } + return buf.String(), nil +} + +// openBrowser opens a URL or file path in the system browser. +func openBrowser(target string) error { + // Try xdg-open (Linux), open (macOS), start (Windows) + for _, bin := range []string{"xdg-open", "open", "start"} { + if binPath, err := exec.LookPath(bin); err == nil { + return exec.Command(binPath, target).Start() + } + } + return nil // silently ignore if no browser found +} diff --git a/tui/styles.go b/tui/styles.go new file mode 100644 index 0000000..4ae4372 --- /dev/null +++ b/tui/styles.go @@ -0,0 +1,30 @@ +package tui + +import "github.com/charmbracelet/lipgloss" + +var ( + colFocusedBorder = lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("63")) + + colNormalBorder = lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("240")) + + statusBarStyle = lipgloss.NewStyle(). + Background(lipgloss.Color("236")). + Foreground(lipgloss.Color("252")). + Padding(0, 1) + + cmdBarStyle = lipgloss.NewStyle(). + Foreground(lipgloss.Color("214")). + Bold(true) + + titleStyle = lipgloss.NewStyle(). + Bold(true). + Foreground(lipgloss.Color("39")) + + dimStyle = lipgloss.NewStyle(). + Foreground(lipgloss.Color("240")) + +)